Annotation of embedaddon/istgt/src/istgt_iscsi.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2008-2011 Daisuke Aoyama <aoyama@peach.ne.jp>.
! 3: * All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice, this list of conditions and the following disclaimer in the
! 12: * documentation and/or other materials provided with the distribution.
! 13: *
! 14: * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 15: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 17: * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
! 18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 19: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 20: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 21: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 22: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 23: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 24: * SUCH DAMAGE.
! 25: *
! 26: */
! 27:
! 28: #ifdef HAVE_CONFIG_H
! 29: #include "config.h"
! 30: #endif
! 31:
! 32: #include <stdint.h>
! 33: #include <inttypes.h>
! 34:
! 35: #include <errno.h>
! 36: #include <signal.h>
! 37: #include <stdio.h>
! 38: #include <stdlib.h>
! 39: #include <string.h>
! 40: #include <poll.h>
! 41: #include <pthread.h>
! 42: #ifdef HAVE_PTHREAD_NP_H
! 43: #include <pthread_np.h>
! 44: #endif
! 45: #include <unistd.h>
! 46: #include <sys/types.h>
! 47: #include <sys/socket.h>
! 48: #include <time.h>
! 49:
! 50: #include "istgt.h"
! 51: #include "istgt_ver.h"
! 52: #include "istgt_log.h"
! 53: #include "istgt_conf.h"
! 54: #include "istgt_sock.h"
! 55: #include "istgt_misc.h"
! 56: #include "istgt_crc32c.h"
! 57: #include "istgt_md5.h"
! 58: #include "istgt_iscsi.h"
! 59: #include "istgt_iscsi_param.h"
! 60: #include "istgt_lu.h"
! 61: #include "istgt_proto.h"
! 62: #include "istgt_scsi.h"
! 63: #include "istgt_queue.h"
! 64:
! 65: #ifdef ISTGT_USE_KQUEUE
! 66: #include <sys/types.h>
! 67: #include <sys/event.h>
! 68: #include <sys/time.h>
! 69: #endif
! 70:
! 71: /* according to RFC1982 */
! 72: #define SN32_CMPMAX (((uint32_t)1U) << (32 - 1))
! 73: #define SN32_LT(S1,S2) \
! 74: (((uint32_t)(S1) != (uint32_t)(S2)) \
! 75: && (((uint32_t)(S1) < (uint32_t)(S2) \
! 76: && ((uint32_t)(S2) - (uint32_t)(S1) < SN32_CMPMAX)) \
! 77: || ((uint32_t)(S1) > (uint32_t)(S2) \
! 78: && ((uint32_t)(S1) - (uint32_t)(S2) > SN32_CMPMAX))))
! 79: #define SN32_GT(S1,S2) \
! 80: (((uint32_t)(S1) != (uint32_t)(S2)) \
! 81: && (((uint32_t)(S1) < (uint32_t)(S2) \
! 82: && ((uint32_t)(S2) - (uint32_t)(S1) > SN32_CMPMAX)) \
! 83: || ((uint32_t)(S1) > (uint32_t)(S2) \
! 84: && ((uint32_t)(S1) - (uint32_t)(S2) < SN32_CMPMAX))))
! 85:
! 86: #define POLLWAIT 3000
! 87: #define MAX_MCSREVWAIT (10 * 1000)
! 88: #define ISCMDQ 8
! 89:
! 90: #define ISCSI_GETVAL(PARAMS,KEY) \
! 91: istgt_iscsi_param_get_val((PARAMS),(KEY))
! 92: #define ISCSI_EQVAL(PARAMS,KEY,VAL) \
! 93: istgt_iscsi_param_eq_val((PARAMS),(KEY),(VAL))
! 94: #define ISCSI_DELVAL(PARAMS,KEY) \
! 95: istgt_iscsi_param_del((PARAMS),(KEY))
! 96: #define ISCSI_ADDVAL(PARAMS,KEY,VAL,LIST,TYPE) \
! 97: istgt_iscsi_param_add((PARAMS),(KEY),(VAL), (LIST), (TYPE))
! 98:
! 99: static int g_nconns;
! 100: static CONN_Ptr *g_conns;
! 101: static pthread_mutex_t g_conns_mutex;
! 102:
! 103: static uint16_t g_last_tsih;
! 104: static pthread_mutex_t g_last_tsih_mutex;
! 105:
! 106: static int istgt_add_transfer_task(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd);
! 107: static void istgt_clear_transfer_task(CONN_Ptr conn, uint32_t CmdSN);
! 108: static void istgt_clear_all_transfer_task(CONN_Ptr conn);
! 109: static int istgt_iscsi_send_r2t(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, int offset, int len, uint32_t transfer_tag, uint32_t *R2TSN);
! 110: static int istgt_append_sess(CONN_Ptr conn, uint64_t isid, uint16_t tsih, uint16_t cid);
! 111: static void istgt_remove_conn(CONN_Ptr conn);
! 112: static int istgt_iscsi_drop_all_conns(CONN_Ptr conn);
! 113: static int istgt_iscsi_drop_old_conns(CONN_Ptr conn);
! 114:
! 115: #if 0
! 116: #define ISTGT_USE_RECVBLOCK
! 117: #define ISTGT_USE_SENDBLOCK
! 118: #endif
! 119: #if 0
! 120: #define ISTGT_USE_RECVWAIT
! 121: #endif
! 122: static ssize_t
! 123: istgt_iscsi_read(CONN_Ptr conn, void *buf, size_t nbytes)
! 124: {
! 125: #ifndef ISTGT_USE_RECVBLOCK
! 126: uint8_t padding[ISCSI_ALIGNMENT];
! 127: #endif
! 128: uint8_t *cp;
! 129: size_t pad_bytes;
! 130: size_t total;
! 131: ssize_t r;
! 132:
! 133: total = 0;
! 134: cp = (uint8_t *) buf;
! 135: #ifdef ISTGT_USE_RECVBLOCK
! 136: pad_bytes = ISCSI_ALIGN(nbytes) - nbytes;
! 137: do {
! 138: #ifdef ISTGT_USE_RECVWAIT
! 139: r = recv(conn->sock, cp + total, (nbytes + pad_bytes - total),
! 140: MSG_WAITALL);
! 141: #else
! 142: r = recv(conn->sock, cp + total, (nbytes + pad_bytes - total),
! 143: 0);
! 144: #endif
! 145: if (r < 0) {
! 146: /* error */
! 147: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 148: "Read error (errno=%d)\n", errno);
! 149: return r;
! 150: }
! 151: if (r == 0) {
! 152: /* EOF */
! 153: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Read EOF\n");
! 154: return r;
! 155: }
! 156: total += r;
! 157: } while (total < nbytes);
! 158: if (total != (nbytes + pad_bytes)) {
! 159: /* incomplete bytes */
! 160: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Read %d/%d+%d bytes\n",
! 161: total, nbytes, pad_bytes);
! 162: if (total > nbytes) {
! 163: total = nbytes;
! 164: }
! 165: return total;
! 166: }
! 167:
! 168: if (pad_bytes != 0) {
! 169: /* complete padding */
! 170: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Read %d bytes (padding %d)\n",
! 171: nbytes, pad_bytes);
! 172: } else {
! 173: /* just aligned */
! 174: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Read %d bytes (no padding)\n",
! 175: nbytes);
! 176: }
! 177: #else /* !ISTGT_USE_RECVBLOCK */
! 178: do {
! 179: r = istgt_read_socket(conn->sock, cp + total, (nbytes - total),
! 180: conn->timeout);
! 181: if (r < 0) {
! 182: /* error */
! 183: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 184: "Read error (errno=%d)\n", errno);
! 185: return r;
! 186: }
! 187: if (r == 0) {
! 188: /* EOF */
! 189: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Read EOF\n");
! 190: return r;
! 191: }
! 192: total += r;
! 193: } while (total < nbytes);
! 194: #if 0
! 195: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "RAW DATA", cp, total);
! 196: #endif
! 197:
! 198: if (total != nbytes) {
! 199: /* incomplete bytes */
! 200: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Read %d/%d bytes\n",
! 201: total, nbytes);
! 202: return total;
! 203: }
! 204:
! 205: /* need padding? */
! 206: pad_bytes = ISCSI_ALIGN(nbytes) - nbytes;
! 207: if (pad_bytes != 0) {
! 208: total = 0;
! 209: cp = (uint8_t *) &padding[0];
! 210: do {
! 211: r = istgt_read_socket(conn->sock, cp + total,
! 212: (pad_bytes - total), conn->timeout);
! 213: if (r < 0) {
! 214: /* error */
! 215: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 216: "Read %d bytes (padding error) (errno=%d)\n",
! 217: nbytes, errno);
! 218: return nbytes;
! 219: }
! 220: if (r == 0) {
! 221: /* EOF */
! 222: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 223: "Read %d bytes (padding EOF)\n",
! 224: nbytes);
! 225: return nbytes;
! 226: }
! 227: total += r;
! 228: } while (total < pad_bytes);
! 229:
! 230: if (total != pad_bytes) {
! 231: /* incomplete padding */
! 232: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 233: "Read %d bytes (padding %d)\n",
! 234: nbytes, total);
! 235: return nbytes;
! 236: }
! 237: /* complete padding */
! 238: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Read %d bytes (padding %d)\n",
! 239: nbytes, pad_bytes);
! 240: return nbytes;
! 241: }
! 242:
! 243: /* just aligned */
! 244: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Read %d bytes (no padding)\n",
! 245: nbytes);
! 246: #endif /* ISTGT_USE_RECVBLOCK */
! 247: return nbytes;
! 248: }
! 249:
! 250: static ssize_t
! 251: istgt_iscsi_write(CONN_Ptr conn, const void *buf, size_t nbytes)
! 252: {
! 253: uint8_t padding[ISCSI_ALIGNMENT];
! 254: const uint8_t *cp;
! 255: size_t pad_bytes;
! 256: size_t total;
! 257: ssize_t r;
! 258:
! 259: total = 0;
! 260: cp = (const uint8_t *) buf;
! 261: #ifdef ISTGT_USE_SENDBLOCK
! 262: pad_bytes = ISCSI_ALIGN(nbytes) - nbytes;
! 263: do {
! 264: r = send(conn->wsock, cp, nbytes, 0);
! 265: if (r < 0) {
! 266: /* error */
! 267: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 268: "Write error (errno=%d)\n", errno);
! 269: return r;
! 270: }
! 271: total += r;
! 272: } while (total < nbytes);
! 273:
! 274: if (total != nbytes) {
! 275: /* incomplete bytes */
! 276: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Write %d/%d bytes\n",
! 277: total, nbytes);
! 278: return total;
! 279: }
! 280:
! 281: if (pad_bytes != 0) {
! 282: memset(padding, 0, sizeof padding);
! 283: total = 0;
! 284: cp = (const uint8_t *) &padding[0];
! 285: do {
! 286: r = send(conn->wsock, cp, pad_bytes, 0);
! 287: if (r < 0) {
! 288: /* error */
! 289: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 290: "Write %d bytes (padding error) (errno=%d)\n",
! 291: nbytes, errno);
! 292: return nbytes;
! 293: }
! 294: total += r;
! 295: } while (total < pad_bytes);
! 296:
! 297: if (total != pad_bytes) {
! 298: /* incomplete padding */
! 299: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 300: "Write %d bytes (padding %d)\n",
! 301: nbytes, total);
! 302: return nbytes;
! 303: }
! 304:
! 305: /* complete padding */
! 306: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 307: "Write %d bytes (padding %d)\n",
! 308: nbytes, pad_bytes);
! 309: } else {
! 310: /* just aligned */
! 311: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 312: "Write %d bytes (no padding)\n",
! 313: nbytes);
! 314: }
! 315: #else /* !ISTGT_USE_SENDBLOCK */
! 316: do {
! 317: r = istgt_write_socket(conn->wsock, cp + total,
! 318: (nbytes - total), conn->timeout);
! 319: if (r < 0) {
! 320: /* error */
! 321: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 322: "Write error (errno=%d)\n", errno);
! 323: return r;
! 324: }
! 325: total += r;
! 326: } while (total < nbytes);
! 327:
! 328: if (total != nbytes) {
! 329: /* incomplete bytes */
! 330: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Write %d/%d bytes\n",
! 331: total, nbytes);
! 332: return r;
! 333: }
! 334:
! 335: /* need padding? */
! 336: pad_bytes = ISCSI_ALIGN(nbytes) - nbytes;
! 337: if (pad_bytes != 0) {
! 338: memset(padding, 0, sizeof padding);
! 339: total = 0;
! 340: cp = (const uint8_t *) &padding[0];
! 341: do {
! 342: r = istgt_write_socket(conn->wsock, cp + total,
! 343: (pad_bytes - total), conn->timeout);
! 344: if (r < 0) {
! 345: /* error */
! 346: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 347: "Write %d bytes (padding error) (errno=%d)\n",
! 348: nbytes, errno);
! 349: return nbytes;
! 350: }
! 351: total += r;
! 352: } while (total < pad_bytes);
! 353:
! 354: if (total != pad_bytes) {
! 355: /* incomplete padding */
! 356: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 357: "Write %d bytes (padding %d)\n",
! 358: nbytes, total);
! 359: return nbytes;
! 360: }
! 361: /* complete padding */
! 362: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 363: "Write %d bytes (padding %d)\n",
! 364: nbytes, pad_bytes);
! 365: return nbytes;
! 366: }
! 367:
! 368: /* just aligned */
! 369: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Write %d bytes (no padding)\n",
! 370: nbytes);
! 371: #endif /* ISTGT_USE_SENDBLOCK */
! 372: return nbytes;
! 373: }
! 374:
! 375: #define MATCH_DIGEST_WORD(BUF, CRC32C) \
! 376: ( ((((uint32_t) *((uint8_t *)(BUF)+0)) << 0) \
! 377: | (((uint32_t) *((uint8_t *)(BUF)+1)) << 8) \
! 378: | (((uint32_t) *((uint8_t *)(BUF)+2)) << 16) \
! 379: | (((uint32_t) *((uint8_t *)(BUF)+3)) << 24)) \
! 380: == (CRC32C))
! 381:
! 382: #define MAKE_DIGEST_WORD(BUF, CRC32C) \
! 383: ( ((*((uint8_t *)(BUF)+0)) = (uint8_t)((uint32_t)(CRC32C) >> 0)), \
! 384: ((*((uint8_t *)(BUF)+1)) = (uint8_t)((uint32_t)(CRC32C) >> 8)), \
! 385: ((*((uint8_t *)(BUF)+2)) = (uint8_t)((uint32_t)(CRC32C) >> 16)), \
! 386: ((*((uint8_t *)(BUF)+3)) = (uint8_t)((uint32_t)(CRC32C) >> 24)))
! 387:
! 388: #if 0
! 389: static int
! 390: istgt_match_digest_word(const uint8_t *buf, uint32_t crc32c)
! 391: {
! 392: uint32_t l;
! 393:
! 394: l = (buf[0] & 0xffU) << 0;
! 395: l |= (buf[1] & 0xffU) << 8;
! 396: l |= (buf[2] & 0xffU) << 16;
! 397: l |= (buf[3] & 0xffU) << 24;
! 398: return (l == crc32c);
! 399: }
! 400:
! 401: static uint8_t *
! 402: istgt_make_digest_word(uint8_t *buf, size_t len, uint32_t crc32c)
! 403: {
! 404: if (len < ISCSI_DIGEST_LEN)
! 405: return NULL;
! 406:
! 407: buf[0] = (crc32c >> 0) & 0xffU;
! 408: buf[1] = (crc32c >> 8) & 0xffU;
! 409: buf[2] = (crc32c >> 16) & 0xffU;
! 410: buf[3] = (crc32c >> 24) & 0xffU;
! 411: return buf;
! 412: }
! 413: #endif
! 414:
! 415: static int
! 416: istgt_iscsi_read_pdu(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 417: {
! 418: uint32_t crc32c;
! 419: int total_ahs_len;
! 420: int data_len;
! 421: int segment_len;
! 422: int total;
! 423: int rc;
! 424:
! 425: pdu->ahs = NULL;
! 426: pdu->total_ahs_len = 0;
! 427: pdu->data = NULL;
! 428: pdu->data_segment_len = 0;
! 429: total = 0;
! 430:
! 431: /* BHS */
! 432: ISTGT_TRACELOG(ISTGT_TRACE_NET, "BHS read %d\n",
! 433: ISCSI_BHS_LEN);
! 434: rc = istgt_iscsi_read(conn, &pdu->bhs, ISCSI_BHS_LEN);
! 435: if (rc < 0) {
! 436: if (errno == ECONNRESET) {
! 437: ISTGT_WARNLOG("Connection reset by peer (%s)\n",
! 438: conn->initiator_name);
! 439: conn->state = CONN_STATE_EXITING;
! 440: } else if (errno == ETIMEDOUT) {
! 441: ISTGT_WARNLOG("Operation timed out (%s)\n",
! 442: conn->initiator_name);
! 443: conn->state = CONN_STATE_EXITING;
! 444: } else {
! 445: ISTGT_ERRLOG("iscsi_read() failed (errno=%d)\n",
! 446: errno);
! 447: }
! 448: return -1;
! 449: }
! 450: if (rc == 0) {
! 451: ISTGT_TRACELOG(ISTGT_TRACE_NET, "iscsi_read() EOF\n");
! 452: conn->state = CONN_STATE_EXITING;
! 453: return -1;
! 454: }
! 455: if (rc != ISCSI_BHS_LEN) {
! 456: ISTGT_ERRLOG("invalid BHS length (%d)\n", rc);
! 457: return -1;
! 458: }
! 459: total += ISCSI_BHS_LEN;
! 460:
! 461: /* AHS */
! 462: total_ahs_len = DGET8(&pdu->bhs.total_ahs_len);
! 463: if (total_ahs_len != 0) {
! 464: pdu->ahs = xmalloc(ISCSI_ALIGN((4 * total_ahs_len)));
! 465: ISTGT_TRACELOG(ISTGT_TRACE_NET, "AHS read %d\n",
! 466: (4 * total_ahs_len));
! 467: rc = istgt_iscsi_read(conn, pdu->ahs, (4 * total_ahs_len));
! 468: if (rc < 0) {
! 469: ISTGT_ERRLOG("iscsi_read() failed\n");
! 470: return -1;
! 471: }
! 472: if (rc == 0) {
! 473: ISTGT_TRACELOG(ISTGT_TRACE_NET, "iscsi_read() EOF\n");
! 474: conn->state = CONN_STATE_EXITING;
! 475: return -1;
! 476: }
! 477: if (rc != (4 * total_ahs_len)) {
! 478: ISTGT_ERRLOG("invalid AHS length (%d)\n", rc);
! 479: return -1;
! 480: }
! 481: pdu->total_ahs_len = total_ahs_len;
! 482: total += (4 * total_ahs_len);
! 483: } else {
! 484: pdu->ahs = NULL;
! 485: pdu->total_ahs_len = 0;
! 486: }
! 487:
! 488: /* Header Digest */
! 489: if (conn->header_digest) {
! 490: ISTGT_TRACELOG(ISTGT_TRACE_NET, "HeaderDigest read %d\n",
! 491: ISCSI_DIGEST_LEN);
! 492: rc = istgt_iscsi_read(conn, pdu->header_digest,
! 493: ISCSI_DIGEST_LEN);
! 494: if (rc < 0) {
! 495: ISTGT_ERRLOG("iscsi_read() failed\n");
! 496: {
! 497: int opcode = BGET8W(&pdu->bhs.opcode, 5, 6);
! 498: ISTGT_ERRLOG("Header Digest read error (opcode = 0x%x)\n",
! 499: opcode);
! 500: }
! 501: return -1;
! 502: }
! 503: if (rc == 0) {
! 504: ISTGT_TRACELOG(ISTGT_TRACE_NET, "iscsi_read() EOF\n");
! 505: conn->state = CONN_STATE_EXITING;
! 506: return -1;
! 507: }
! 508: if (rc != ISCSI_DIGEST_LEN) {
! 509: ISTGT_ERRLOG("invalid Header Digest length (%d)\n",
! 510: rc);
! 511: return -1;
! 512: }
! 513: total += ISCSI_DIGEST_LEN;
! 514: }
! 515:
! 516: /* Data Segment */
! 517: data_len = DGET24(&pdu->bhs.data_segment_len[0]);
! 518: if (data_len != 0) {
! 519: if (conn->sess == NULL) {
! 520: segment_len = DEFAULT_FIRSTBURSTLENGTH;
! 521: } else {
! 522: segment_len = conn->MaxRecvDataSegmentLength;
! 523: }
! 524: if (data_len > segment_len) {
! 525: ISTGT_ERRLOG("Data(%d) > Segment(%d)\n",
! 526: data_len, segment_len);
! 527: return -1;
! 528: }
! 529: if (ISCSI_ALIGN(data_len) <= ISTGT_SHORTDATASIZE) {
! 530: pdu->data = pdu->shortdata;
! 531: } else {
! 532: pdu->data = xmalloc(ISCSI_ALIGN(segment_len));
! 533: }
! 534: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Data read %d\n",
! 535: data_len);
! 536: rc = istgt_iscsi_read(conn, pdu->data, data_len);
! 537: if (rc < 0) {
! 538: ISTGT_ERRLOG("iscsi_read() failed (%d,errno=%d)\n",
! 539: rc, errno);
! 540: return -1;
! 541: }
! 542: if (rc == 0) {
! 543: ISTGT_TRACELOG(ISTGT_TRACE_NET, "iscsi_read() EOF\n");
! 544: conn->state = CONN_STATE_EXITING;
! 545: return -1;
! 546: }
! 547: if (rc != data_len) {
! 548: ISTGT_ERRLOG("invalid Data Segment length (%d)\n", rc);
! 549: return -1;
! 550: }
! 551: pdu->data_segment_len = data_len;
! 552: total += data_len;
! 553:
! 554: #if 0
! 555: if (data_len > 512) {
! 556: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "DataSegment",
! 557: pdu->data, 512);
! 558: } else {
! 559: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "DataSegment",
! 560: pdu->data, data_len);
! 561: }
! 562: #endif
! 563: } else {
! 564: pdu->data = NULL;
! 565: pdu->data_segment_len = 0;
! 566: }
! 567:
! 568: /* Data Digest */
! 569: if (conn->data_digest && data_len != 0) {
! 570: ISTGT_TRACELOG(ISTGT_TRACE_NET, "DataDigest read %d\n",
! 571: ISCSI_DIGEST_LEN);
! 572: rc = istgt_iscsi_read(conn, pdu->data_digest,
! 573: ISCSI_DIGEST_LEN);
! 574: if (rc < 0) {
! 575: ISTGT_ERRLOG("iscsi_read() failed\n");
! 576: return -1;
! 577: }
! 578: if (rc == 0) {
! 579: ISTGT_TRACELOG(ISTGT_TRACE_NET, "iscsi_read() EOF\n");
! 580: conn->state = CONN_STATE_EXITING;
! 581: return -1;
! 582: }
! 583: if (rc != ISCSI_DIGEST_LEN) {
! 584: ISTGT_ERRLOG("invalid Data Digest length (%d)\n", rc);
! 585: return -1;
! 586: }
! 587: total += ISCSI_DIGEST_LEN;
! 588: }
! 589:
! 590: /* check digest */
! 591: if (conn->header_digest) {
! 592: if (total_ahs_len == 0) {
! 593: crc32c = istgt_crc32c((uint8_t *) &pdu->bhs,
! 594: ISCSI_BHS_LEN);
! 595: } else {
! 596: int upd_total = 0;
! 597: crc32c = ISTGT_CRC32C_INITIAL;
! 598: crc32c = istgt_update_crc32c((uint8_t *) &pdu->bhs,
! 599: ISCSI_BHS_LEN, crc32c);
! 600: upd_total += ISCSI_BHS_LEN;
! 601: crc32c = istgt_update_crc32c((uint8_t *) pdu->ahs,
! 602: (4 * total_ahs_len), crc32c);
! 603: upd_total += (4 * total_ahs_len);
! 604: crc32c = istgt_fixup_crc32c(upd_total, crc32c);
! 605: crc32c = crc32c ^ ISTGT_CRC32C_XOR;
! 606: }
! 607: rc = MATCH_DIGEST_WORD(pdu->header_digest, crc32c);
! 608: if (rc == 0) {
! 609: ISTGT_ERRLOG("header digest error\n");
! 610: return -1;
! 611: }
! 612: }
! 613: if (conn->data_digest && data_len != 0) {
! 614: crc32c = istgt_crc32c(pdu->data, data_len);
! 615: rc = MATCH_DIGEST_WORD(pdu->data_digest, crc32c);
! 616: if (rc == 0) {
! 617: ISTGT_ERRLOG("data digest error\n");
! 618: return -1;
! 619: }
! 620: }
! 621:
! 622: return total;
! 623: }
! 624:
! 625: static int istgt_iscsi_write_pdu_internal(CONN_Ptr conn, ISCSI_PDU_Ptr pdu);
! 626:
! 627: static int
! 628: istgt_iscsi_write_pdu(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 629: {
! 630: int rc;
! 631:
! 632: if (conn->use_sender == 0) {
! 633: rc = istgt_iscsi_write_pdu_internal(conn, pdu);
! 634: } else {
! 635: ISTGT_LU_TASK_Ptr lu_task;
! 636: ISCSI_PDU_Ptr src_pdu, dst_pdu;
! 637: uint8_t *cp;
! 638: int total_ahs_len;
! 639: int data_len;
! 640: int alloc_len;
! 641: int total;
! 642:
! 643: cp = (uint8_t *) &pdu->bhs;
! 644: total_ahs_len = DGET8(&cp[4]);
! 645: data_len = DGET24(&cp[5]);
! 646: total = 0;
! 647:
! 648: #if 0
! 649: ISTGT_LOG("W:PDU OP=%x, tag=%x, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 650: DGET8(&cp[0]), DGET32(&cp[32]), DGET32(&cp[28]), DGET32(&cp[32]));
! 651: #endif
! 652: /* allocate for queued PDU */
! 653: alloc_len = ISCSI_ALIGN(sizeof *lu_task);
! 654: alloc_len += ISCSI_ALIGN(sizeof *lu_task->lu_cmd.pdu);
! 655: alloc_len += ISCSI_ALIGN(4 * total_ahs_len);
! 656: alloc_len += ISCSI_ALIGN(data_len);
! 657: lu_task = xmalloc(alloc_len);
! 658: memset(lu_task, 0, alloc_len);
! 659: lu_task->lu_cmd.pdu = (ISCSI_PDU_Ptr) ((uint8_t *)lu_task
! 660: + ISCSI_ALIGN(sizeof *lu_task));
! 661: lu_task->lu_cmd.pdu->ahs = (ISCSI_AHS *) ((uint8_t *)lu_task->lu_cmd.pdu
! 662: + ISCSI_ALIGN(sizeof *lu_task->lu_cmd.pdu));
! 663: lu_task->lu_cmd.pdu->data = (uint8_t *)lu_task->lu_cmd.pdu->ahs
! 664: + ISCSI_ALIGN(4 * total_ahs_len);
! 665:
! 666: /* specify type and self conn */
! 667: lu_task->type = ISTGT_LU_TASK_REQPDU;
! 668: lu_task->conn = conn;
! 669:
! 670: /* copy PDU structure */
! 671: src_pdu = pdu;
! 672: dst_pdu = lu_task->lu_cmd.pdu;
! 673: memcpy(&dst_pdu->bhs, &src_pdu->bhs, ISCSI_BHS_LEN);
! 674: total += ISCSI_BHS_LEN;
! 675: if (total_ahs_len != 0) {
! 676: memcpy(dst_pdu->ahs, src_pdu->ahs, 4 * total_ahs_len);
! 677: total += (4 * total_ahs_len);
! 678: } else {
! 679: dst_pdu->ahs = NULL;
! 680: }
! 681: if (conn->header_digest) {
! 682: memcpy(dst_pdu->header_digest, src_pdu->header_digest,
! 683: ISCSI_DIGEST_LEN);
! 684: total += ISCSI_DIGEST_LEN;
! 685: }
! 686: if (data_len != 0) {
! 687: memcpy(dst_pdu->data, src_pdu->data, data_len);
! 688: total += data_len;
! 689: } else {
! 690: dst_pdu->data = NULL;
! 691: }
! 692: if (conn->data_digest && data_len != 0) {
! 693: memcpy(dst_pdu->data_digest, src_pdu->data_digest,
! 694: ISCSI_DIGEST_LEN);
! 695: total += ISCSI_DIGEST_LEN;
! 696: }
! 697:
! 698: /* insert to queue */
! 699: MTX_LOCK(&conn->result_queue_mutex);
! 700: rc = istgt_queue_enqueue(&conn->result_queue, lu_task);
! 701: if (rc != 0) {
! 702: MTX_UNLOCK(&conn->result_queue_mutex);
! 703: ISTGT_ERRLOG("queue_enqueue() failed\n");
! 704: return -1;
! 705: }
! 706: /* notify to thread */
! 707: rc = pthread_cond_broadcast(&conn->result_queue_cond);
! 708: MTX_UNLOCK(&conn->result_queue_mutex);
! 709: if (rc != 0) {
! 710: ISTGT_ERRLOG("cond_broadcast() failed\n");
! 711: return -1;
! 712: }
! 713:
! 714: /* total bytes should be sent in queue */
! 715: rc = total;
! 716: }
! 717: return rc;
! 718: }
! 719:
! 720: static int
! 721: istgt_iscsi_write_pdu_internal(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 722: {
! 723: uint8_t *cp;
! 724: uint32_t crc32c;
! 725: int enable_digest;
! 726: int opcode;
! 727: int total_ahs_len;
! 728: int data_len;
! 729: int total;
! 730: int rc;
! 731:
! 732: cp = (uint8_t *) &pdu->bhs;
! 733: total_ahs_len = DGET8(&cp[4]);
! 734: data_len = DGET24(&cp[5]);
! 735: total = 0;
! 736:
! 737: enable_digest = 1;
! 738: opcode = BGET8W(&cp[0], 5, 6);
! 739: if (opcode == ISCSI_OP_LOGIN_RSP) {
! 740: /* this PDU should be sent without digest */
! 741: enable_digest = 0;
! 742: }
! 743:
! 744: #define ISTGT_USE_SHORTPDU_WRITE
! 745: #ifdef ISTGT_USE_SHORTPDU_WRITE
! 746: /* if short size, BHS + AHS + HD + DATA + DD */
! 747: if (total_ahs_len == 0
! 748: && data_len <= ISTGT_SHORTDATASIZE) {
! 749: uint8_t *spp = conn->shortpdu;
! 750: int pad_len = 0;
! 751: memcpy(spp, (uint8_t *) &pdu->bhs, ISCSI_BHS_LEN);
! 752: total = ISCSI_BHS_LEN;
! 753: if (enable_digest && conn->header_digest) {
! 754: crc32c = istgt_crc32c(spp, total);
! 755: MAKE_DIGEST_WORD(spp + total, crc32c);
! 756: total += ISCSI_DIGEST_LEN;
! 757: }
! 758: memcpy(spp + total, pdu->data, data_len);
! 759: total += data_len;
! 760: if ((data_len % ISCSI_ALIGNMENT) != 0) {
! 761: memset(spp + total, 0,
! 762: ISCSI_ALIGN(data_len) - data_len);
! 763: total += ISCSI_ALIGN(data_len) - data_len;
! 764: pad_len += ISCSI_ALIGN(data_len) - data_len;
! 765: }
! 766: if (enable_digest && conn->data_digest && data_len != 0) {
! 767: crc32c = istgt_crc32c(pdu->data, data_len);
! 768: MAKE_DIGEST_WORD(spp + total, crc32c);
! 769: total += ISCSI_DIGEST_LEN;
! 770: }
! 771:
! 772: ISTGT_TRACELOG(ISTGT_TRACE_NET, "PDU write %d\n",
! 773: total);
! 774: rc = istgt_iscsi_write(conn, spp, total);
! 775: if (rc < 0) {
! 776: ISTGT_ERRLOG("iscsi_write() failed (errno=%d)\n",
! 777: errno);
! 778: return -1;
! 779: }
! 780: if (rc != total) {
! 781: ISTGT_ERRLOG("incomplete PDU length (%d)\n", rc);
! 782: return -1;
! 783: }
! 784: return total - pad_len;
! 785: }
! 786: #endif /* ISTGT_USE_SHORTPDU_WRITE */
! 787:
! 788: /* BHS */
! 789: ISTGT_TRACELOG(ISTGT_TRACE_NET, "BHS write %d\n",
! 790: ISCSI_BHS_LEN);
! 791: rc = istgt_iscsi_write(conn, &pdu->bhs, ISCSI_BHS_LEN);
! 792: if (rc < 0) {
! 793: ISTGT_ERRLOG("iscsi_write() failed (errno=%d)\n", errno);
! 794: return -1;
! 795: }
! 796: if (rc != ISCSI_BHS_LEN) {
! 797: ISTGT_ERRLOG("incomplete BHS length (%d)\n", rc);
! 798: return -1;
! 799: }
! 800: total += ISCSI_BHS_LEN;
! 801:
! 802: /* AHS */
! 803: if (total_ahs_len != 0) {
! 804: ISTGT_TRACELOG(ISTGT_TRACE_NET, "AHS write %d\n",
! 805: (4 * total_ahs_len));
! 806: rc = istgt_iscsi_write(conn, pdu->ahs, (4 * total_ahs_len));
! 807: if (rc < 0) {
! 808: ISTGT_ERRLOG("iscsi_write() failed\n");
! 809: return -1;
! 810: }
! 811: if (rc != (4 * total_ahs_len)) {
! 812: ISTGT_ERRLOG("incomplete AHS length (%d)\n", rc);
! 813: return -1;
! 814: }
! 815: total += (4 * total_ahs_len);
! 816: }
! 817:
! 818: /* Header Digest */
! 819: if (enable_digest && conn->header_digest) {
! 820: if (total_ahs_len == 0) {
! 821: crc32c = istgt_crc32c((uint8_t *) &pdu->bhs,
! 822: ISCSI_BHS_LEN);
! 823: } else {
! 824: int upd_total = 0;
! 825: crc32c = ISTGT_CRC32C_INITIAL;
! 826: crc32c = istgt_update_crc32c((uint8_t *) &pdu->bhs,
! 827: ISCSI_BHS_LEN, crc32c);
! 828: upd_total += ISCSI_BHS_LEN;
! 829: crc32c = istgt_update_crc32c((uint8_t *) pdu->ahs,
! 830: (4 * total_ahs_len), crc32c);
! 831: upd_total += (4 * total_ahs_len);
! 832: crc32c = istgt_fixup_crc32c(upd_total, crc32c);
! 833: crc32c = crc32c ^ ISTGT_CRC32C_XOR;
! 834: }
! 835: MAKE_DIGEST_WORD(pdu->header_digest, crc32c);
! 836:
! 837: ISTGT_TRACELOG(ISTGT_TRACE_NET, "HeaderDigest write %d\n",
! 838: ISCSI_DIGEST_LEN);
! 839: rc = istgt_iscsi_write(conn, pdu->header_digest,
! 840: ISCSI_DIGEST_LEN);
! 841: if (rc < 0) {
! 842: ISTGT_ERRLOG("iscsi_write() failed\n");
! 843: return -1;
! 844: }
! 845: if (rc != ISCSI_DIGEST_LEN) {
! 846: ISTGT_ERRLOG("incomplete Header Digest length (%d)\n",
! 847: rc);
! 848: return -1;
! 849: }
! 850: total += ISCSI_DIGEST_LEN;
! 851: }
! 852:
! 853: /* Data Segment */
! 854: if (data_len != 0) {
! 855: ISTGT_TRACELOG(ISTGT_TRACE_NET, "Data write %d\n",
! 856: data_len);
! 857: rc = istgt_iscsi_write(conn, pdu->data, data_len);
! 858: if (rc < 0) {
! 859: ISTGT_ERRLOG("iscsi_write() failed\n");
! 860: return -1;
! 861: }
! 862: if (rc != data_len) {
! 863: ISTGT_ERRLOG("incomplete Data Segment length (%d)\n",
! 864: rc);
! 865: return -1;
! 866: }
! 867: total += data_len;
! 868: }
! 869:
! 870: /* Data Digest */
! 871: if (enable_digest && conn->data_digest && data_len != 0) {
! 872: crc32c = istgt_crc32c(pdu->data, data_len);
! 873: MAKE_DIGEST_WORD(pdu->data_digest, crc32c);
! 874:
! 875: ISTGT_TRACELOG(ISTGT_TRACE_NET, "DataDigest write %d\n",
! 876: ISCSI_DIGEST_LEN);
! 877: ISTGT_TRACELOG(ISTGT_TRACE_NET, "DataDigest %x\n",
! 878: crc32c);
! 879: rc = istgt_iscsi_write(conn, pdu->data_digest,
! 880: ISCSI_DIGEST_LEN);
! 881: if (rc < 0) {
! 882: ISTGT_ERRLOG("iscsi_write() failed\n");
! 883: return -1;
! 884: }
! 885: if (rc != ISCSI_DIGEST_LEN) {
! 886: ISTGT_ERRLOG("incomplete Data Digest length (%d)\n",
! 887: rc);
! 888: return -1;
! 889: }
! 890: total += ISCSI_DIGEST_LEN;
! 891: }
! 892:
! 893: return total;
! 894: }
! 895:
! 896: int
! 897: istgt_iscsi_copy_pdu(ISCSI_PDU_Ptr dst_pdu, ISCSI_PDU_Ptr src_pdu)
! 898: {
! 899: memcpy(&dst_pdu->bhs, &src_pdu->bhs, ISCSI_BHS_LEN);
! 900: dst_pdu->ahs = src_pdu->ahs;
! 901: memcpy(dst_pdu->header_digest, src_pdu->header_digest,
! 902: ISCSI_DIGEST_LEN);
! 903: if (src_pdu->data == src_pdu->shortdata) {
! 904: memcpy(dst_pdu->shortdata, src_pdu->shortdata,
! 905: sizeof src_pdu->shortdata);
! 906: dst_pdu->data = dst_pdu->shortdata;
! 907: } else {
! 908: dst_pdu->data = src_pdu->data;
! 909: }
! 910: memcpy(dst_pdu->data_digest, src_pdu->data_digest, ISCSI_DIGEST_LEN);
! 911: dst_pdu->total_ahs_len = src_pdu->total_ahs_len;
! 912: dst_pdu->data_segment_len = src_pdu->data_segment_len;
! 913: dst_pdu->copy_pdu = 0;
! 914: src_pdu->copy_pdu = 1;
! 915: return 0;
! 916: }
! 917:
! 918: typedef struct iscsi_param_table_t
! 919: {
! 920: const char *key;
! 921: const char *val;
! 922: const char *list;
! 923: int type;
! 924: } ISCSI_PARAM_TABLE;
! 925:
! 926: static ISCSI_PARAM_TABLE conn_param_table[] =
! 927: {
! 928: { "HeaderDigest", "None", "CRC32C,None", ISPT_LIST },
! 929: { "DataDigest", "None", "CRC32C,None", ISPT_LIST },
! 930: { "MaxRecvDataSegmentLength", "8192", "512,16777215", ISPT_NUMERICAL },
! 931: { "OFMarker", "No", "Yes,No", ISPT_BOOLEAN_AND },
! 932: { "IFMarker", "No", "Yes,No", ISPT_BOOLEAN_AND },
! 933: { "OFMarkInt", "1", "1,65535", ISPT_NUMERICAL },
! 934: { "IFMarkInt", "1", "1,65535", ISPT_NUMERICAL },
! 935: { "AuthMethod", "None", "CHAP,None", ISPT_LIST },
! 936: { "CHAP_A", "5", "5", ISPT_LIST },
! 937: { "CHAP_N", "", "", ISPT_DECLARATIVE },
! 938: { "CHAP_R", "", "", ISPT_DECLARATIVE },
! 939: { "CHAP_I", "", "", ISPT_DECLARATIVE },
! 940: { "CHAP_C", "", "", ISPT_DECLARATIVE },
! 941: { NULL, NULL, NULL, ISPT_INVALID },
! 942: };
! 943:
! 944: static ISCSI_PARAM_TABLE sess_param_table[] =
! 945: {
! 946: { "MaxConnections", "1", "1,65535", ISPT_NUMERICAL },
! 947: #if 0
! 948: /* need special handling */
! 949: { "SendTargets", "", "", ISPT_DECLARATIVE },
! 950: #endif
! 951: { "TargetName", "", "", ISPT_DECLARATIVE },
! 952: { "InitiatorName", "", "", ISPT_DECLARATIVE },
! 953: { "TargetAlias", "", "", ISPT_DECLARATIVE },
! 954: { "InitiatorAlias", "", "", ISPT_DECLARATIVE },
! 955: { "TargetAddress", "", "", ISPT_DECLARATIVE },
! 956: { "TargetPortalGroupTag", "1", "1,65535", ISPT_NUMERICAL },
! 957: { "InitialR2T", "Yes", "Yes,No", ISPT_BOOLEAN_OR },
! 958: { "ImmediateData", "Yes", "Yes,No", ISPT_BOOLEAN_AND },
! 959: { "MaxBurstLength", "262144", "512,16777215", ISPT_NUMERICAL },
! 960: { "FirstBurstLength", "65536", "512,16777215", ISPT_NUMERICAL },
! 961: { "DefaultTime2Wait", "2", "0,3600", ISPT_NUMERICAL_MAX },
! 962: { "DefaultTime2Retain", "20", "0,3600", ISPT_NUMERICAL },
! 963: { "MaxOutstandingR2T", "1", "1,65536", ISPT_NUMERICAL },
! 964: { "DataPDUInOrder", "Yes", "Yes,No", ISPT_BOOLEAN_OR },
! 965: { "DataSequenceInOrder", "Yes", "Yes,No", ISPT_BOOLEAN_OR },
! 966: { "ErrorRecoveryLevel", "0", "0,2", ISPT_NUMERICAL },
! 967: { "SessionType", "Normal", "Normal,Discovery", ISPT_DECLARATIVE },
! 968: { NULL, NULL, NULL, ISPT_INVALID },
! 969: };
! 970:
! 971: static int
! 972: istgt_iscsi_params_init_internal(ISCSI_PARAM **params, ISCSI_PARAM_TABLE *table)
! 973: {
! 974: int rc;
! 975: int i;
! 976:
! 977: for (i = 0; table[i].key != NULL; i++) {
! 978: rc = istgt_iscsi_param_add(params, table[i].key, table[i].val,
! 979: table[i].list, table[i].type);
! 980: if (rc < 0) {
! 981: ISTGT_ERRLOG("iscsi_param_add() failed\n");
! 982: return -1;
! 983: }
! 984: }
! 985:
! 986: return 0;
! 987: }
! 988:
! 989: static int
! 990: istgt_iscsi_conn_params_init(ISCSI_PARAM **params)
! 991: {
! 992: return istgt_iscsi_params_init_internal(params, &conn_param_table[0]);
! 993: }
! 994:
! 995: static int
! 996: istgt_iscsi_sess_params_init(ISCSI_PARAM **params)
! 997: {
! 998: return istgt_iscsi_params_init_internal(params, &sess_param_table[0]);
! 999: }
! 1000:
! 1001: static char *
! 1002: istgt_iscsi_param_get_val(ISCSI_PARAM *params, const char *key)
! 1003: {
! 1004: ISCSI_PARAM *param;
! 1005:
! 1006: param = istgt_iscsi_param_find(params, key);
! 1007: if (param == NULL)
! 1008: return NULL;
! 1009: return param->val;
! 1010: }
! 1011:
! 1012: static int
! 1013: istgt_iscsi_param_eq_val(ISCSI_PARAM *params, const char *key, const char *val)
! 1014: {
! 1015: ISCSI_PARAM *param;
! 1016:
! 1017: param = istgt_iscsi_param_find(params, key);
! 1018: if (param == NULL)
! 1019: return 0;
! 1020: if (strcasecmp(param->val, val) == 0)
! 1021: return 1;
! 1022: return 0;
! 1023: }
! 1024:
! 1025: #if 0
! 1026: static int
! 1027: istgt_iscsi_print_params(ISCSI_PARAM *params)
! 1028: {
! 1029: ISCSI_PARAM *param;
! 1030:
! 1031: for (param = params; param != NULL; param = param->next) {
! 1032: printf("key=[%s] val=[%s] list=[%s] type=%d\n",
! 1033: param->key, param->val, param->list, param->type);
! 1034: }
! 1035: return 0;
! 1036: }
! 1037: #endif
! 1038:
! 1039: static int
! 1040: istgt_iscsi_negotiate_params(CONN_Ptr conn, ISCSI_PARAM *params, uint8_t *data, int alloc_len, int data_len)
! 1041: {
! 1042: ISCSI_PARAM *param;
! 1043: ISCSI_PARAM *cur_param;
! 1044: char *valid_list, *in_val;
! 1045: char *valid_next, *in_next;
! 1046: char *cur_val;
! 1047: char *new_val;
! 1048: char *valid_val;
! 1049: char *min_val, *max_val;
! 1050: int discovery;
! 1051: int cur_type;
! 1052: int val_i, cur_val_i;
! 1053: int min_i, max_i;
! 1054: int total;
! 1055: int len;
! 1056: int sw;
! 1057:
! 1058: total = data_len;
! 1059: if (alloc_len < 1) {
! 1060: return 0;
! 1061: }
! 1062: if (total > alloc_len) {
! 1063: total = alloc_len;
! 1064: data[total - 1] = '\0';
! 1065: return total;
! 1066: }
! 1067:
! 1068: if (params == NULL) {
! 1069: /* no input */
! 1070: return total;
! 1071: }
! 1072:
! 1073: /* discovery? */
! 1074: discovery = 0;
! 1075: cur_param = istgt_iscsi_param_find(params, "SessionType");
! 1076: if (cur_param == NULL) {
! 1077: SESS_MTX_LOCK(conn);
! 1078: cur_param = istgt_iscsi_param_find(conn->sess->params, "SessionType");
! 1079: if (cur_param == NULL) {
! 1080: /* no session type */
! 1081: } else {
! 1082: if (strcasecmp(cur_param->val, "Discovery") == 0) {
! 1083: discovery = 1;
! 1084: }
! 1085: }
! 1086: SESS_MTX_UNLOCK(conn);
! 1087: } else {
! 1088: if (strcasecmp(cur_param->val, "Discovery") == 0) {
! 1089: discovery = 1;
! 1090: }
! 1091: }
! 1092:
! 1093: /* for temporary store */
! 1094: valid_list = xmalloc(ISCSI_TEXT_MAX_VAL_LEN + 1);
! 1095: in_val = xmalloc(ISCSI_TEXT_MAX_VAL_LEN + 1);
! 1096: cur_val = xmalloc(ISCSI_TEXT_MAX_VAL_LEN + 1);
! 1097:
! 1098: for (param = params; param != NULL; param = param->next) {
! 1099: /* sendtargets is special */
! 1100: if (strcasecmp(param->key, "SendTargets") == 0) {
! 1101: continue;
! 1102: }
! 1103: /* CHAP keys */
! 1104: if (strcasecmp(param->key, "CHAP_A") == 0
! 1105: || strcasecmp(param->key, "CHAP_N") == 0
! 1106: || strcasecmp(param->key, "CHAP_R") == 0
! 1107: || strcasecmp(param->key, "CHAP_I") == 0
! 1108: || strcasecmp(param->key, "CHAP_C") == 0) {
! 1109: continue;
! 1110: }
! 1111:
! 1112: if (discovery) {
! 1113: /* 12.2, 12.10, 12.11, 12.13, 12.14, 12.17, 12.18, 12.19 */
! 1114: if (strcasecmp(param->key, "MaxConnections") == 0
! 1115: || strcasecmp(param->key, "InitialR2T") == 0
! 1116: || strcasecmp(param->key, "ImmediateData") == 0
! 1117: || strcasecmp(param->key, "MaxBurstLength") == 0
! 1118: || strcasecmp(param->key, "FirstBurstLength") == 0
! 1119: || strcasecmp(param->key, "MaxOutstandingR2T") == 0
! 1120: || strcasecmp(param->key, "DataPDUInOrder") == 0
! 1121: || strcasecmp(param->key, "DataSequenceInOrder") == 0) {
! 1122: strlcpy(in_val, "Irrelevant",
! 1123: ISCSI_TEXT_MAX_VAL_LEN);
! 1124: new_val = in_val;
! 1125: cur_type = -1;
! 1126: goto add_val;
! 1127: }
! 1128: }
! 1129:
! 1130: /* get current param */
! 1131: sw = 0;
! 1132: cur_param = istgt_iscsi_param_find(conn->params, param->key);
! 1133: if (cur_param == NULL) {
! 1134: sw = 1;
! 1135: SESS_MTX_LOCK(conn);
! 1136: cur_param = istgt_iscsi_param_find(conn->sess->params,
! 1137: param->key);
! 1138: if (cur_param == NULL) {
! 1139: SESS_MTX_UNLOCK(conn);
! 1140: if (strncasecmp(param->key, "X-", 2) == 0
! 1141: || strncasecmp(param->key, "X#", 2) == 0) {
! 1142: /* Extension Key */
! 1143: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1144: "extension key %.64s\n",
! 1145: param->key);
! 1146: } else {
! 1147: ISTGT_ERRLOG("unknown key %.64s\n",
! 1148: param->key);
! 1149: }
! 1150: strlcpy(in_val, "NotUnderstood",
! 1151: ISCSI_TEXT_MAX_VAL_LEN);
! 1152: new_val = in_val;
! 1153: cur_type = -1;
! 1154: goto add_val;
! 1155: }
! 1156: strlcpy(valid_list, cur_param->list,
! 1157: ISCSI_TEXT_MAX_VAL_LEN);
! 1158: strlcpy(cur_val, cur_param->val,
! 1159: ISCSI_TEXT_MAX_VAL_LEN);
! 1160: cur_type = cur_param->type;
! 1161: SESS_MTX_UNLOCK(conn);
! 1162: } else {
! 1163: strlcpy(valid_list, cur_param->list,
! 1164: ISCSI_TEXT_MAX_VAL_LEN);
! 1165: strlcpy(cur_val, cur_param->val,
! 1166: ISCSI_TEXT_MAX_VAL_LEN);
! 1167: cur_type = cur_param->type;
! 1168: }
! 1169:
! 1170: /* negotiate value */
! 1171: switch (cur_type) {
! 1172: case ISPT_LIST:
! 1173: strlcpy(in_val, param->val, ISCSI_TEXT_MAX_VAL_LEN);
! 1174: in_next = in_val;
! 1175: while ((new_val = strsepq(&in_next, ",")) != NULL) {
! 1176: valid_next = valid_list;
! 1177: while ((valid_val = strsepq(&valid_next, ",")) != NULL) {
! 1178: if (strcasecmp(new_val, valid_val) == 0) {
! 1179: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "match %s\n",
! 1180: new_val);
! 1181: goto update_val;
! 1182: }
! 1183: }
! 1184: }
! 1185: if (new_val == NULL) {
! 1186: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1187: "key %.64s reject\n",
! 1188: param->key);
! 1189: strlcpy(in_val, "Reject",
! 1190: ISCSI_TEXT_MAX_VAL_LEN);
! 1191: new_val = in_val;
! 1192: goto add_val;
! 1193: }
! 1194: break;
! 1195:
! 1196: case ISPT_NUMERICAL:
! 1197: val_i = (int) strtol(param->val, NULL, 10);
! 1198: cur_val_i = (int) strtol(cur_val, NULL, 10);
! 1199: valid_next = valid_list;
! 1200: min_val = strsepq(&valid_next, ",");
! 1201: max_val = strsepq(&valid_next, ",");
! 1202: if (min_val != NULL) {
! 1203: min_i = (int) strtol(min_val, NULL, 10);
! 1204: } else {
! 1205: min_i = 0;
! 1206: }
! 1207: if (max_val != NULL) {
! 1208: max_i = (int) strtol(max_val, NULL, 10);
! 1209: } else {
! 1210: max_i = 0;
! 1211: }
! 1212: if (val_i < min_i || val_i > max_i) {
! 1213: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1214: "key %.64s reject\n",
! 1215: param->key);
! 1216: strlcpy(in_val, "Reject",
! 1217: ISCSI_TEXT_MAX_VAL_LEN);
! 1218: new_val = in_val;
! 1219: goto add_val;
! 1220: }
! 1221: if (strcasecmp(param->key, "MaxRecvDataSegmentLength") == 0) {
! 1222: /* Declarative, but set as same value */
! 1223: cur_val_i = conn->TargetMaxRecvDataSegmentLength;
! 1224: }
! 1225: if (val_i > cur_val_i) {
! 1226: val_i = cur_val_i;
! 1227: }
! 1228: snprintf(in_val, ISCSI_TEXT_MAX_VAL_LEN, "%d", val_i);
! 1229: new_val = in_val;
! 1230: break;
! 1231:
! 1232: case ISPT_NUMERICAL_MAX:
! 1233: val_i = (int) strtol(param->val, NULL, 10);
! 1234: cur_val_i = (int) strtol(cur_val, NULL, 10);
! 1235: valid_next = valid_list;
! 1236: min_val = strsepq(&valid_next, ",");
! 1237: max_val = strsepq(&valid_next, ",");
! 1238: if (min_val != NULL) {
! 1239: min_i = (int) strtol(min_val, NULL, 10);
! 1240: } else {
! 1241: min_i = 0;
! 1242: }
! 1243: if (max_val != NULL) {
! 1244: max_i = (int) strtol(max_val, NULL, 10);
! 1245: } else {
! 1246: max_i = 0;
! 1247: }
! 1248: if (val_i < min_i || val_i > max_i) {
! 1249: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1250: "key %.64s reject\n",
! 1251: param->key);
! 1252: strlcpy(in_val, "Reject",
! 1253: ISCSI_TEXT_MAX_VAL_LEN);
! 1254: new_val = in_val;
! 1255: goto add_val;
! 1256: }
! 1257: if (val_i < cur_val_i) {
! 1258: val_i = cur_val_i;
! 1259: }
! 1260: snprintf(in_val, ISCSI_TEXT_MAX_VAL_LEN, "%d", val_i);
! 1261: new_val = in_val;
! 1262: break;
! 1263:
! 1264: case ISPT_BOOLEAN_OR:
! 1265: if (strcasecmp(cur_val, "Yes") == 0) {
! 1266: /* YES || XXX */
! 1267: strlcpy(in_val, "Yes", ISCSI_TEXT_MAX_VAL_LEN);
! 1268: new_val = in_val;
! 1269: } else {
! 1270: if (strcasecmp(param->val, "Yes") == 0
! 1271: || strcasecmp(param->val, "No") == 0) {
! 1272: new_val = param->val;
! 1273: } else {
! 1274: /* unknown value */
! 1275: strlcpy(in_val, "Reject",
! 1276: ISCSI_TEXT_MAX_VAL_LEN);
! 1277: new_val = in_val;
! 1278: goto add_val;
! 1279: }
! 1280: }
! 1281: break;
! 1282:
! 1283: case ISPT_BOOLEAN_AND:
! 1284: if (strcasecmp(cur_val, "No") == 0) {
! 1285: /* No && XXX */
! 1286: strlcpy(in_val, "No", ISCSI_TEXT_MAX_VAL_LEN);
! 1287: new_val = in_val;
! 1288: } else {
! 1289: if (strcasecmp(param->val, "Yes") == 0
! 1290: || strcasecmp(param->val, "No") == 0) {
! 1291: new_val = param->val;
! 1292: } else {
! 1293: /* unknown value */
! 1294: strlcpy(in_val, "Reject",
! 1295: ISCSI_TEXT_MAX_VAL_LEN);
! 1296: new_val = in_val;
! 1297: goto add_val;
! 1298: }
! 1299: }
! 1300: break;
! 1301:
! 1302: case ISPT_DECLARATIVE:
! 1303: strlcpy(in_val, param->val, ISCSI_TEXT_MAX_VAL_LEN);
! 1304: new_val = in_val;
! 1305: break;
! 1306:
! 1307: default:
! 1308: strlcpy(in_val, param->val, ISCSI_TEXT_MAX_VAL_LEN);
! 1309: new_val = in_val;
! 1310: break;
! 1311: }
! 1312:
! 1313: update_val:
! 1314: if (sw) {
! 1315: /* update session wide */
! 1316: SESS_MTX_LOCK(conn);
! 1317: istgt_iscsi_param_set(conn->sess->params, param->key,
! 1318: new_val);
! 1319: SESS_MTX_UNLOCK(conn);
! 1320: } else {
! 1321: /* update connection only */
! 1322: istgt_iscsi_param_set(conn->params, param->key,
! 1323: new_val);
! 1324: }
! 1325: add_val:
! 1326: if (cur_type != ISPT_DECLARATIVE) {
! 1327: if (alloc_len - total < 1) {
! 1328: ISTGT_ERRLOG("data space small %d\n",
! 1329: alloc_len);
! 1330: return total;
! 1331: }
! 1332: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI, "negotiated %s=%s\n",
! 1333: param->key, new_val);
! 1334: len = snprintf((char *) data + total,
! 1335: alloc_len - total, "%s=%s",
! 1336: param->key, new_val);
! 1337: total += len + 1;
! 1338: }
! 1339: }
! 1340:
! 1341: xfree(valid_list);
! 1342: xfree(in_val);
! 1343: xfree(cur_val);
! 1344:
! 1345: return total;
! 1346: }
! 1347:
! 1348: static int
! 1349: istgt_iscsi_append_text(CONN_Ptr conn, const char *key, const char *val, uint8_t *data, int alloc_len, int data_len)
! 1350: {
! 1351: int total;
! 1352: int len;
! 1353:
! 1354: total = data_len;
! 1355: if (alloc_len < 1) {
! 1356: return 0;
! 1357: }
! 1358: if (total > alloc_len) {
! 1359: total = alloc_len;
! 1360: data[total - 1] = '\0';
! 1361: return total;
! 1362: }
! 1363:
! 1364: if (alloc_len - total < 1) {
! 1365: ISTGT_ERRLOG("data space small %d\n", alloc_len);
! 1366: return total;
! 1367: }
! 1368: len = snprintf((char *) data + total, alloc_len - total, "%s=%s",
! 1369: key, val);
! 1370: total += len + 1;
! 1371:
! 1372: return total;
! 1373: }
! 1374:
! 1375: static int
! 1376: istgt_iscsi_append_param(CONN_Ptr conn, const char *key, uint8_t *data, int alloc_len, int data_len)
! 1377: {
! 1378: ISCSI_PARAM *param;
! 1379: int rc;
! 1380:
! 1381: param = istgt_iscsi_param_find(conn->params, key);
! 1382: if (param == NULL) {
! 1383: param = istgt_iscsi_param_find(conn->sess->params, key);
! 1384: if (param == NULL) {
! 1385: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "no key %.64s\n",
! 1386: key);
! 1387: return data_len;
! 1388: }
! 1389: }
! 1390: rc = istgt_iscsi_append_text(conn, param->key, param->val, data,
! 1391: alloc_len, data_len);
! 1392: return rc;
! 1393: }
! 1394:
! 1395: int
! 1396: istgt_chap_get_authinfo(ISTGT_CHAP_AUTH *auth, const char *authfile, const char *authuser, int ag_tag)
! 1397: {
! 1398: CONFIG *config = NULL;
! 1399: CF_SECTION *sp;
! 1400: const char *val;
! 1401: const char *user, *muser;
! 1402: const char *secret, *msecret;
! 1403: int rc;
! 1404: int i;
! 1405:
! 1406: if (auth->user != NULL) {
! 1407: xfree(auth->user);
! 1408: xfree(auth->secret);
! 1409: xfree(auth->muser);
! 1410: xfree(auth->msecret);
! 1411: auth->user = auth->secret = NULL;
! 1412: auth->muser = auth->msecret = NULL;
! 1413: }
! 1414:
! 1415: /* read config files */
! 1416: config = istgt_allocate_config();
! 1417: rc = istgt_read_config(config, authfile);
! 1418: if (rc < 0) {
! 1419: ISTGT_ERRLOG("auth conf error\n");
! 1420: istgt_free_config(config);
! 1421: return -1;
! 1422: }
! 1423: //istgt_print_config(config);
! 1424:
! 1425: sp = config->section;
! 1426: while (sp != NULL) {
! 1427: if (sp->type == ST_AUTHGROUP) {
! 1428: if (sp->num == 0) {
! 1429: ISTGT_ERRLOG("Group 0 is invalid\n");
! 1430: istgt_free_config(config);
! 1431: return -1;
! 1432: }
! 1433: if (ag_tag != sp->num) {
! 1434: goto skip_ag_tag;
! 1435: }
! 1436:
! 1437: val = istgt_get_val(sp, "Comment");
! 1438: if (val != NULL) {
! 1439: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1440: "Comment %s\n", val);
! 1441: }
! 1442: for (i = 0; ; i++) {
! 1443: val = istgt_get_nval(sp, "Auth", i);
! 1444: if (val == NULL)
! 1445: break;
! 1446: user = istgt_get_nmval(sp, "Auth", i, 0);
! 1447: secret = istgt_get_nmval(sp, "Auth", i, 1);
! 1448: muser = istgt_get_nmval(sp, "Auth", i, 2);
! 1449: msecret = istgt_get_nmval(sp, "Auth", i, 3);
! 1450: if (strcasecmp(authuser, user) == 0) {
! 1451: /* match user */
! 1452: auth->user = xstrdup(user);
! 1453: auth->secret = xstrdup(secret);
! 1454: auth->muser = xstrdup(muser);
! 1455: auth->msecret = xstrdup(msecret);
! 1456: istgt_free_config(config);
! 1457: return 0;
! 1458: }
! 1459: }
! 1460: }
! 1461: skip_ag_tag:
! 1462: sp = sp->next;
! 1463: }
! 1464:
! 1465: istgt_free_config(config);
! 1466: return 0;
! 1467: }
! 1468:
! 1469: static int
! 1470: istgt_iscsi_get_authinfo(CONN_Ptr conn, const char *authuser)
! 1471: {
! 1472: char *authfile = NULL;
! 1473: int ag_tag;
! 1474: int rc;
! 1475:
! 1476: SESS_MTX_LOCK(conn);
! 1477: if (conn->sess->lu != NULL) {
! 1478: ag_tag = conn->sess->lu->auth_group;
! 1479: } else {
! 1480: ag_tag = -1;
! 1481: }
! 1482: SESS_MTX_UNLOCK(conn);
! 1483: if (ag_tag < 0) {
! 1484: MTX_LOCK(&conn->istgt->mutex);
! 1485: ag_tag = conn->istgt->discovery_auth_group;
! 1486: MTX_UNLOCK(&conn->istgt->mutex);
! 1487: }
! 1488: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "ag_tag=%d\n", ag_tag);
! 1489:
! 1490: MTX_LOCK(&conn->istgt->mutex);
! 1491: authfile = xstrdup(conn->istgt->authfile);
! 1492: MTX_UNLOCK(&conn->istgt->mutex);
! 1493:
! 1494: rc = istgt_chap_get_authinfo(&conn->auth, authfile, authuser, ag_tag);
! 1495: if (rc < 0) {
! 1496: ISTGT_ERRLOG("chap_get_authinfo() failed\n");
! 1497: xfree(authfile);
! 1498: return -1;
! 1499: }
! 1500: xfree(authfile);
! 1501: return 0;
! 1502: }
! 1503:
! 1504: static int
! 1505: istgt_iscsi_auth_params(CONN_Ptr conn, ISCSI_PARAM *params, const char *method, uint8_t *data, int alloc_len, int data_len)
! 1506: {
! 1507: char *in_val;
! 1508: char *in_next;
! 1509: char *new_val;
! 1510: const char *val;
! 1511: const char *user;
! 1512: const char *response;
! 1513: const char *challenge;
! 1514: int total;
! 1515: int rc;
! 1516:
! 1517: if (conn == NULL || params == NULL || method == NULL) {
! 1518: return -1;
! 1519: }
! 1520: if (strcasecmp(method, "CHAP") == 0) {
! 1521: /* method OK */
! 1522: } else {
! 1523: ISTGT_ERRLOG("unsupported AuthMethod %.64s\n", method);
! 1524: return -1;
! 1525: }
! 1526:
! 1527: total = data_len;
! 1528: if (alloc_len < 1) {
! 1529: return 0;
! 1530: }
! 1531: if (total > alloc_len) {
! 1532: total = alloc_len;
! 1533: data[total - 1] = '\0';
! 1534: return total;
! 1535: }
! 1536:
! 1537: /* for temporary store */
! 1538: in_val = xmalloc(ISCSI_TEXT_MAX_VAL_LEN + 1);
! 1539:
! 1540: /* CHAP method (RFC1994) */
! 1541: if ((val = ISCSI_GETVAL(params, "CHAP_A")) != NULL) {
! 1542: if (conn->auth.chap_phase != ISTGT_CHAP_PHASE_WAIT_A) {
! 1543: ISTGT_ERRLOG("CHAP sequence error\n");
! 1544: goto error_return;
! 1545: }
! 1546:
! 1547: /* CHAP_A is LIST type */
! 1548: strlcpy(in_val, val, ISCSI_TEXT_MAX_VAL_LEN);
! 1549: in_next = in_val;
! 1550: while ((new_val = strsepq(&in_next, ",")) != NULL) {
! 1551: if (strcasecmp(new_val, "5") == 0) {
! 1552: /* CHAP with MD5 */
! 1553: break;
! 1554: }
! 1555: }
! 1556: if (new_val == NULL) {
! 1557: strlcpy(in_val, "Reject", ISCSI_TEXT_MAX_VAL_LEN);
! 1558: new_val = in_val;
! 1559: total = istgt_iscsi_append_text(conn, "CHAP_A",
! 1560: new_val, data, alloc_len, total);
! 1561: goto error_return;
! 1562: }
! 1563: /* selected algorithm is 5 (MD5) */
! 1564: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "got CHAP_A=%s\n", new_val);
! 1565: total = istgt_iscsi_append_text(conn, "CHAP_A", new_val,
! 1566: data, alloc_len, total);
! 1567:
! 1568: /* Identifier is one octet */
! 1569: istgt_gen_random(conn->auth.chap_id, 1);
! 1570: snprintf(in_val, ISCSI_TEXT_MAX_VAL_LEN, "%d",
! 1571: (int) conn->auth.chap_id[0]);
! 1572: total = istgt_iscsi_append_text(conn, "CHAP_I", in_val,
! 1573: data, alloc_len, total);
! 1574:
! 1575: /* Challenge Value is a variable stream of octets */
! 1576: /* (binary length MUST not exceed 1024 bytes) */
! 1577: conn->auth.chap_challenge_len = ISTGT_CHAP_CHALLENGE_LEN;
! 1578: istgt_gen_random(conn->auth.chap_challenge,
! 1579: conn->auth.chap_challenge_len);
! 1580: istgt_bin2hex(in_val, ISCSI_TEXT_MAX_VAL_LEN,
! 1581: conn->auth.chap_challenge,
! 1582: conn->auth.chap_challenge_len);
! 1583: total = istgt_iscsi_append_text(conn, "CHAP_C", in_val,
! 1584: data, alloc_len, total);
! 1585:
! 1586: conn->auth.chap_phase = ISTGT_CHAP_PHASE_WAIT_NR;
! 1587: } else if ((val = ISCSI_GETVAL(params, "CHAP_N")) != NULL) {
! 1588: uint8_t resmd5[ISTGT_MD5DIGEST_LEN];
! 1589: uint8_t tgtmd5[ISTGT_MD5DIGEST_LEN];
! 1590: ISTGT_MD5CTX md5ctx;
! 1591:
! 1592: user = val;
! 1593: if (conn->auth.chap_phase != ISTGT_CHAP_PHASE_WAIT_NR) {
! 1594: ISTGT_ERRLOG("CHAP sequence error\n");
! 1595: goto error_return;
! 1596: }
! 1597:
! 1598: response = ISCSI_GETVAL(params, "CHAP_R");
! 1599: if (response == NULL) {
! 1600: ISTGT_ERRLOG("no response\n");
! 1601: goto error_return;
! 1602: }
! 1603: rc = istgt_hex2bin(resmd5, ISTGT_MD5DIGEST_LEN, response);
! 1604: if (rc < 0 || rc != ISTGT_MD5DIGEST_LEN) {
! 1605: ISTGT_ERRLOG("response format error\n");
! 1606: goto error_return;
! 1607: }
! 1608: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "got CHAP_N/CHAP_R\n");
! 1609:
! 1610: rc = istgt_iscsi_get_authinfo(conn, val);
! 1611: if (rc < 0) {
! 1612: //ISTGT_ERRLOG("auth user or secret is missing\n");
! 1613: ISTGT_ERRLOG("iscsi_get_authinfo() failed\n");
! 1614: goto error_return;
! 1615: }
! 1616: if (conn->auth.user == NULL || conn->auth.secret == NULL) {
! 1617: //ISTGT_ERRLOG("auth user or secret is missing\n");
! 1618: ISTGT_ERRLOG("auth failed (user %.64s)\n", user);
! 1619: goto error_return;
! 1620: }
! 1621:
! 1622: istgt_md5init(&md5ctx);
! 1623: /* Identifier */
! 1624: istgt_md5update(&md5ctx, conn->auth.chap_id, 1);
! 1625: /* followed by secret */
! 1626: istgt_md5update(&md5ctx, conn->auth.secret,
! 1627: strlen(conn->auth.secret));
! 1628: /* followed by Challenge Value */
! 1629: istgt_md5update(&md5ctx, conn->auth.chap_challenge,
! 1630: conn->auth.chap_challenge_len);
! 1631: /* tgtmd5 is expecting Response Value */
! 1632: istgt_md5final(tgtmd5, &md5ctx);
! 1633:
! 1634: istgt_bin2hex(in_val, ISCSI_TEXT_MAX_VAL_LEN,
! 1635: tgtmd5, ISTGT_MD5DIGEST_LEN);
! 1636:
! 1637: #if 0
! 1638: printf("tgtmd5=%s, resmd5=%s\n", in_val, response);
! 1639: istgt_dump("tgtmd5", tgtmd5, ISTGT_MD5DIGEST_LEN);
! 1640: istgt_dump("resmd5", resmd5, ISTGT_MD5DIGEST_LEN);
! 1641: #endif
! 1642:
! 1643: /* compare MD5 digest */
! 1644: if (memcmp(tgtmd5, resmd5, ISTGT_MD5DIGEST_LEN) != 0) {
! 1645: /* not match */
! 1646: //ISTGT_ERRLOG("auth user or secret is missing\n");
! 1647: ISTGT_ERRLOG("auth failed (user %.64s)\n", user);
! 1648: goto error_return;
! 1649: }
! 1650: /* OK initiator's secret */
! 1651: conn->authenticated = 1;
! 1652:
! 1653: /* mutual CHAP? */
! 1654: val = ISCSI_GETVAL(params, "CHAP_I");
! 1655: if (val != NULL) {
! 1656: conn->auth.chap_mid[0] = (uint8_t) strtol(val, NULL, 10);
! 1657: challenge = ISCSI_GETVAL(params, "CHAP_C");
! 1658: if (challenge == NULL) {
! 1659: ISTGT_ERRLOG("CHAP sequence error\n");
! 1660: goto error_return;
! 1661: }
! 1662: rc = istgt_hex2bin(conn->auth.chap_mchallenge,
! 1663: ISTGT_CHAP_CHALLENGE_LEN,
! 1664: challenge);
! 1665: if (rc < 0) {
! 1666: ISTGT_ERRLOG("challenge format error\n");
! 1667: goto error_return;
! 1668: }
! 1669: conn->auth.chap_mchallenge_len = rc;
! 1670: #if 0
! 1671: istgt_dump("MChallenge", conn->auth.chap_mchallenge,
! 1672: conn->auth.chap_mchallenge_len);
! 1673: #endif
! 1674: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1675: "got CHAP_I/CHAP_C\n");
! 1676:
! 1677: if (conn->auth.muser == NULL || conn->auth.msecret == NULL) {
! 1678: //ISTGT_ERRLOG("mutual auth user or secret is missing\n");
! 1679: ISTGT_ERRLOG("auth failed (user %.64s)\n",
! 1680: user);
! 1681: goto error_return;
! 1682: }
! 1683:
! 1684: istgt_md5init(&md5ctx);
! 1685: /* Identifier */
! 1686: istgt_md5update(&md5ctx, conn->auth.chap_mid, 1);
! 1687: /* followed by secret */
! 1688: istgt_md5update(&md5ctx, conn->auth.msecret,
! 1689: strlen(conn->auth.msecret));
! 1690: /* followed by Challenge Value */
! 1691: istgt_md5update(&md5ctx, conn->auth.chap_mchallenge,
! 1692: conn->auth.chap_mchallenge_len);
! 1693: /* tgtmd5 is Response Value */
! 1694: istgt_md5final(tgtmd5, &md5ctx);
! 1695:
! 1696: istgt_bin2hex(in_val, ISCSI_TEXT_MAX_VAL_LEN,
! 1697: tgtmd5, ISTGT_MD5DIGEST_LEN);
! 1698:
! 1699: total = istgt_iscsi_append_text(conn, "CHAP_N",
! 1700: conn->auth.muser, data, alloc_len, total);
! 1701: total = istgt_iscsi_append_text(conn, "CHAP_R",
! 1702: in_val, data, alloc_len, total);
! 1703: } else {
! 1704: /* not mutual */
! 1705: if (conn->req_mutual) {
! 1706: ISTGT_ERRLOG("required mutual CHAP\n");
! 1707: goto error_return;
! 1708: }
! 1709: }
! 1710:
! 1711: conn->auth.chap_phase = ISTGT_CHAP_PHASE_END;
! 1712: } else {
! 1713: /* not found CHAP keys */
! 1714: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "start CHAP\n");
! 1715: conn->auth.chap_phase = ISTGT_CHAP_PHASE_WAIT_A;
! 1716: }
! 1717:
! 1718: xfree(in_val);
! 1719: return total;
! 1720:
! 1721: error_return:
! 1722: conn->auth.chap_phase = ISTGT_CHAP_PHASE_WAIT_A;
! 1723: xfree(in_val);
! 1724: return -1;
! 1725: }
! 1726:
! 1727: static int
! 1728: istgt_iscsi_reject(CONN_Ptr conn, ISCSI_PDU_Ptr pdu, int reason)
! 1729: {
! 1730: ISCSI_PDU rsp_pdu;
! 1731: uint8_t *rsp;
! 1732: uint8_t *data;
! 1733: int total_ahs_len;
! 1734: int data_len;
! 1735: int alloc_len;
! 1736: int rc;
! 1737:
! 1738: total_ahs_len = DGET8(&pdu->bhs.total_ahs_len);
! 1739: data_len = 0;
! 1740: alloc_len = ISCSI_BHS_LEN + (4 * total_ahs_len);
! 1741: if (conn->header_digest) {
! 1742: alloc_len += ISCSI_DIGEST_LEN;
! 1743: }
! 1744: data = xmalloc(alloc_len);
! 1745: memset(data, 0, alloc_len);
! 1746:
! 1747: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1748: "Reject PDU reason=%d\n",
! 1749: reason);
! 1750: if (conn->sess != NULL) {
! 1751: SESS_MTX_LOCK(conn);
! 1752: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 1753: "StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 1754: conn->StatSN, conn->sess->ExpCmdSN,
! 1755: conn->sess->MaxCmdSN);
! 1756: SESS_MTX_UNLOCK(conn);
! 1757: } else {
! 1758: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 1759: "StatSN=%u\n",
! 1760: conn->StatSN);
! 1761: }
! 1762:
! 1763: memcpy(data, &pdu->bhs, ISCSI_BHS_LEN);
! 1764: data_len += ISCSI_BHS_LEN;
! 1765: if (total_ahs_len != 0) {
! 1766: memcpy(data + data_len, pdu->ahs, (4 * total_ahs_len));
! 1767: data_len += (4 * total_ahs_len);
! 1768: }
! 1769: if (conn->header_digest) {
! 1770: memcpy(data + data_len, pdu->header_digest, ISCSI_DIGEST_LEN);
! 1771: data_len += ISCSI_DIGEST_LEN;
! 1772: }
! 1773:
! 1774: rsp = (uint8_t *) &rsp_pdu.bhs;
! 1775: rsp_pdu.data = data;
! 1776: memset(rsp, 0, ISCSI_BHS_LEN);
! 1777: rsp[0] = ISCSI_OP_REJECT;
! 1778: BDADD8W(&rsp[1], 1, 7, 1);
! 1779: rsp[2] = reason;
! 1780: rsp[4] = 0; // TotalAHSLength
! 1781: DSET24(&rsp[5], data_len); // DataSegmentLength
! 1782:
! 1783: DSET32(&rsp[16], 0xffffffffU);
! 1784:
! 1785: DSET32(&rsp[24], conn->StatSN);
! 1786: conn->StatSN++;
! 1787: if (conn->sess != NULL) {
! 1788: SESS_MTX_LOCK(conn);
! 1789: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 1790: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 1791: SESS_MTX_UNLOCK(conn);
! 1792: } else {
! 1793: DSET32(&rsp[28], 1);
! 1794: DSET32(&rsp[32], 1);
! 1795: }
! 1796: DSET32(&rsp[36], 0); // DataSN/R2TSN
! 1797:
! 1798: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "PDU", rsp, ISCSI_BHS_LEN);
! 1799:
! 1800: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 1801: if (rc < 0) {
! 1802: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 1803: xfree(data);
! 1804: return -1;
! 1805: }
! 1806:
! 1807: xfree(data);
! 1808: return 0;
! 1809: }
! 1810:
! 1811: static void
! 1812: istgt_iscsi_copy_param2var(CONN_Ptr conn)
! 1813: {
! 1814: const char *val;
! 1815:
! 1816: val = ISCSI_GETVAL(conn->params, "MaxRecvDataSegmentLength");
! 1817: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1818: "copy MaxRecvDataSegmentLength=%s\n", val);
! 1819: conn->MaxRecvDataSegmentLength = (int) strtol(val, NULL, 10);
! 1820: if (conn->sendbufsize != conn->MaxRecvDataSegmentLength) {
! 1821: xfree(conn->recvbuf);
! 1822: xfree(conn->sendbuf);
! 1823: if (conn->MaxRecvDataSegmentLength < 8192) {
! 1824: conn->recvbufsize = 8192;
! 1825: conn->sendbufsize = 8192;
! 1826: } else {
! 1827: conn->recvbufsize = conn->MaxRecvDataSegmentLength;
! 1828: conn->sendbufsize = conn->MaxRecvDataSegmentLength;
! 1829: }
! 1830: conn->recvbuf = xmalloc(conn->recvbufsize);
! 1831: conn->sendbuf = xmalloc(conn->sendbufsize);
! 1832: }
! 1833: val = ISCSI_GETVAL(conn->params, "HeaderDigest");
! 1834: if (strcasecmp(val, "CRC32C") == 0) {
! 1835: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "set HeaderDigest=1\n");
! 1836: conn->header_digest = 1;
! 1837: } else {
! 1838: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "set HeaderDigest=0\n");
! 1839: conn->header_digest = 0;
! 1840: }
! 1841: val = ISCSI_GETVAL(conn->params, "DataDigest");
! 1842: if (strcasecmp(val, "CRC32C") == 0) {
! 1843: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "set DataDigest=1\n");
! 1844: conn->data_digest = 1;
! 1845: } else {
! 1846: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "set DataDigest=0\n");
! 1847: conn->data_digest = 0;
! 1848: }
! 1849:
! 1850: SESS_MTX_LOCK(conn);
! 1851: val = ISCSI_GETVAL(conn->sess->params, "MaxConnections");
! 1852: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "copy MaxConnections=%s\n", val);
! 1853: conn->sess->MaxConnections = (int) strtol(val, NULL, 10);
! 1854: val = ISCSI_GETVAL(conn->sess->params, "MaxOutstandingR2T");
! 1855: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "copy MaxOutstandingR2T=%s\n", val);
! 1856: conn->sess->MaxOutstandingR2T = (int) strtol(val, NULL, 10);
! 1857: conn->MaxOutstandingR2T = conn->sess->MaxOutstandingR2T;
! 1858: val = ISCSI_GETVAL(conn->sess->params, "FirstBurstLength");
! 1859: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "copy FirstBurstLength=%s\n", val);
! 1860: conn->sess->FirstBurstLength = (int) strtol(val, NULL, 10);
! 1861: conn->FirstBurstLength = conn->sess->FirstBurstLength;
! 1862: val = ISCSI_GETVAL(conn->sess->params, "MaxBurstLength");
! 1863: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "copy MaxBurstLength=%s\n", val);
! 1864: conn->sess->MaxBurstLength = (int) strtol(val, NULL, 10);
! 1865: conn->MaxBurstLength = conn->sess->MaxBurstLength;
! 1866: val = ISCSI_GETVAL(conn->sess->params, "InitialR2T");
! 1867: if (strcasecmp(val, "Yes") == 0) {
! 1868: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "set InitialR2T=1\n");
! 1869: conn->sess->initial_r2t = 1;
! 1870: } else{
! 1871: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "set InitialR2T=0\n");
! 1872: conn->sess->initial_r2t = 0;
! 1873: }
! 1874: val = ISCSI_GETVAL(conn->sess->params, "ImmediateData");
! 1875: if (strcasecmp(val, "Yes") == 0) {
! 1876: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "set ImmediateData=1\n");
! 1877: conn->sess->immediate_data = 1;
! 1878: } else {
! 1879: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "set ImmediateData=0\n");
! 1880: conn->sess->immediate_data = 0;
! 1881: }
! 1882: SESS_MTX_UNLOCK(conn);
! 1883: }
! 1884:
! 1885: static int
! 1886: istgt_iscsi_check_values(CONN_Ptr conn)
! 1887: {
! 1888: SESS_MTX_LOCK(conn);
! 1889: if (conn->sess->FirstBurstLength > conn->sess->MaxBurstLength) {
! 1890: ISTGT_ERRLOG("FirstBurstLength(%d) > MaxBurstLength(%d)\n",
! 1891: conn->sess->FirstBurstLength,
! 1892: conn->sess->MaxBurstLength);
! 1893: SESS_MTX_UNLOCK(conn);
! 1894: return -1;
! 1895: }
! 1896: if (conn->sess->MaxBurstLength > 0x00ffffff) {
! 1897: ISTGT_ERRLOG("MaxBurstLength(%d) > 0x00ffffff\n",
! 1898: conn->sess->MaxBurstLength);
! 1899: SESS_MTX_UNLOCK(conn);
! 1900: return -1;
! 1901: }
! 1902: if (conn->TargetMaxRecvDataSegmentLength < 512) {
! 1903: ISTGT_ERRLOG("MaxRecvDataSegmentLength(%d) < 512\n",
! 1904: conn->TargetMaxRecvDataSegmentLength);
! 1905: return -1;
! 1906: }
! 1907: if (conn->TargetMaxRecvDataSegmentLength > 0x00ffffff) {
! 1908: ISTGT_ERRLOG("MaxRecvDataSegmentLength(%d) > 0x00ffffff\n",
! 1909: conn->TargetMaxRecvDataSegmentLength);
! 1910: SESS_MTX_UNLOCK(conn);
! 1911: return -1;
! 1912: }
! 1913: if (conn->MaxRecvDataSegmentLength < 512) {
! 1914: ISTGT_ERRLOG("MaxRecvDataSegmentLength(%d) < 512\n",
! 1915: conn->MaxRecvDataSegmentLength);
! 1916: return -1;
! 1917: }
! 1918: if (conn->MaxRecvDataSegmentLength > 0x00ffffff) {
! 1919: ISTGT_ERRLOG("MaxRecvDataSegmentLength(%d) > 0x00ffffff\n",
! 1920: conn->MaxRecvDataSegmentLength);
! 1921: SESS_MTX_UNLOCK(conn);
! 1922: return -1;
! 1923: }
! 1924: SESS_MTX_UNLOCK(conn);
! 1925: return 0;
! 1926: }
! 1927:
! 1928: static int
! 1929: istgt_iscsi_op_login(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 1930: {
! 1931: char buf[MAX_TMPBUF];
! 1932: ISTGT_LU_Ptr lu = NULL;
! 1933: ISCSI_PARAM *params = NULL;
! 1934: ISCSI_PDU rsp_pdu;
! 1935: uint8_t *rsp;
! 1936: uint8_t *cp;
! 1937: uint8_t *data;
! 1938: const char *session_type;
! 1939: const char *auth_method;
! 1940: const char *val;
! 1941: uint64_t isid;
! 1942: uint16_t tsih;
! 1943: uint16_t cid;
! 1944: uint32_t task_tag;
! 1945: uint32_t CmdSN;
! 1946: uint32_t ExpStatSN;
! 1947: int T_bit, C_bit;
! 1948: int CSG, NSG;
! 1949: int VersionMin, VersionMax;
! 1950: int StatusClass, StatusDetail;
! 1951: int data_len;
! 1952: int alloc_len;
! 1953: int rc;
! 1954:
! 1955: /* Login is proceeding OK */
! 1956: StatusClass = 0x00;
! 1957: StatusDetail = 0x00;
! 1958:
! 1959: data_len = 0;
! 1960:
! 1961: if (conn->MaxRecvDataSegmentLength < 8192) {
! 1962: // Default MaxRecvDataSegmentLength - RFC3720(12.12)
! 1963: alloc_len = 8192;
! 1964: } else {
! 1965: alloc_len = conn->MaxRecvDataSegmentLength;
! 1966: }
! 1967: data = xmalloc(alloc_len);
! 1968: memset(data, 0, alloc_len);
! 1969:
! 1970: cp = (uint8_t *) &pdu->bhs;
! 1971: T_bit = BGET8(&cp[1], 7);
! 1972: C_bit = BGET8(&cp[1], 6);
! 1973: CSG = BGET8W(&cp[1], 3, 2);
! 1974: NSG = BGET8W(&cp[1], 1, 2);
! 1975: VersionMin = cp[2];
! 1976: VersionMax = cp[3];
! 1977:
! 1978: isid = DGET48(&cp[8]);
! 1979: tsih = DGET16(&cp[14]);
! 1980: cid = DGET16(&cp[20]);
! 1981: task_tag = DGET32(&cp[16]);
! 1982: CmdSN = DGET32(&cp[24]);
! 1983: ExpStatSN = DGET32(&cp[28]);
! 1984:
! 1985: #if 1
! 1986: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "PDU", cp, ISCSI_BHS_LEN);
! 1987: #endif
! 1988:
! 1989: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 1990: "T=%d, C=%d, CSG=%d, NSG=%d, Min=%d, Max=%d, ITT=%x\n",
! 1991: T_bit, C_bit, CSG, NSG, VersionMin, VersionMax, task_tag);
! 1992: if (conn->sess != NULL) {
! 1993: SESS_MTX_LOCK(conn);
! 1994: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 1995: "CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 1996: CmdSN, ExpStatSN, conn->StatSN, conn->sess->ExpCmdSN,
! 1997: conn->sess->MaxCmdSN);
! 1998: SESS_MTX_UNLOCK(conn);
! 1999: } else {
! 2000: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 2001: "CmdSN=%u, ExpStatSN=%u, StatSN=%u\n",
! 2002: CmdSN, ExpStatSN, conn->StatSN);
! 2003: }
! 2004:
! 2005: if (T_bit && C_bit) {
! 2006: ISTGT_ERRLOG("transit error\n");
! 2007: xfree(data);
! 2008: return -1;
! 2009: }
! 2010: if (VersionMin > ISCSI_VERSION || VersionMax < ISCSI_VERSION) {
! 2011: ISTGT_ERRLOG("unsupported version %d/%d\n", VersionMin, VersionMax);
! 2012: /* Unsupported version */
! 2013: StatusClass = 0x02;
! 2014: StatusDetail = 0x05;
! 2015: goto response;
! 2016: }
! 2017:
! 2018: /* store incoming parameters */
! 2019: rc = istgt_iscsi_parse_params(¶ms, pdu->data, pdu->data_segment_len);
! 2020: if (rc < 0) {
! 2021: ISTGT_ERRLOG("iscsi_parse_params() failed\n");
! 2022: error_return:
! 2023: istgt_iscsi_param_free(params);
! 2024: xfree(data);
! 2025: return -1;
! 2026: }
! 2027:
! 2028: /* set port identifiers and parameters */
! 2029: if (conn->login_phase == ISCSI_LOGIN_PHASE_NONE) {
! 2030: /* Initiator Name and Port */
! 2031: val = ISCSI_GETVAL(params, "InitiatorName");
! 2032: if (val == NULL) {
! 2033: ISTGT_ERRLOG("InitiatorName is empty\n");
! 2034: /* Missing parameter */
! 2035: StatusClass = 0x02;
! 2036: StatusDetail = 0x07;
! 2037: goto response;
! 2038: }
! 2039: snprintf(conn->initiator_name, sizeof conn->initiator_name,
! 2040: "%s", val);
! 2041: snprintf(conn->initiator_port, sizeof conn->initiator_port,
! 2042: "%s" ",i,0x" "%12.12" PRIx64, val, isid);
! 2043: strlwr(conn->initiator_name);
! 2044: strlwr(conn->initiator_port);
! 2045: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Initiator name: %s\n",
! 2046: conn->initiator_name);
! 2047: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Initiator port: %s\n",
! 2048: conn->initiator_port);
! 2049:
! 2050: /* Session Type */
! 2051: session_type = ISCSI_GETVAL(params, "SessionType");
! 2052: if (session_type == NULL) {
! 2053: if (tsih != 0) {
! 2054: session_type = "Normal";
! 2055: } else {
! 2056: ISTGT_ERRLOG("SessionType is empty\n");
! 2057: /* Missing parameter */
! 2058: StatusClass = 0x02;
! 2059: StatusDetail = 0x07;
! 2060: goto response;
! 2061: }
! 2062: }
! 2063: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Session Type: %s\n",
! 2064: session_type);
! 2065:
! 2066: /* Target Name and Port */
! 2067: if (strcasecmp(session_type, "Normal") == 0) {
! 2068: val = ISCSI_GETVAL(params, "TargetName");
! 2069: if (val == NULL) {
! 2070: ISTGT_ERRLOG("TargetName is empty\n");
! 2071: /* Missing parameter */
! 2072: StatusClass = 0x02;
! 2073: StatusDetail = 0x07;
! 2074: goto response;
! 2075: }
! 2076: snprintf(conn->target_name, sizeof conn->target_name,
! 2077: "%s", val);
! 2078: snprintf(conn->target_port, sizeof conn->target_port,
! 2079: "%s" ",t,0x" "%4.4x", val, conn->portal.tag);
! 2080: strlwr(conn->target_name);
! 2081: strlwr(conn->target_port);
! 2082:
! 2083: MTX_LOCK(&conn->istgt->mutex);
! 2084: lu = istgt_lu_find_target(conn->istgt,
! 2085: conn->target_name);
! 2086: if (lu == NULL) {
! 2087: MTX_UNLOCK(&conn->istgt->mutex);
! 2088: ISTGT_ERRLOG("lu_find_target() failed\n");
! 2089: /* Not found */
! 2090: StatusClass = 0x02;
! 2091: StatusDetail = 0x03;
! 2092: goto response;
! 2093: }
! 2094: rc = istgt_lu_access(conn, lu, conn->initiator_name,
! 2095: conn->initiator_addr);
! 2096: if (rc < 0) {
! 2097: MTX_UNLOCK(&conn->istgt->mutex);
! 2098: ISTGT_ERRLOG("lu_access() failed\n");
! 2099: /* Not found */
! 2100: StatusClass = 0x02;
! 2101: StatusDetail = 0x03;
! 2102: goto response;
! 2103: }
! 2104: if (rc == 0) {
! 2105: MTX_UNLOCK(&conn->istgt->mutex);
! 2106: ISTGT_ERRLOG("access denied\n");
! 2107: /* Not found */
! 2108: StatusClass = 0x02;
! 2109: StatusDetail = 0x03;
! 2110: goto response;
! 2111: }
! 2112: MTX_UNLOCK(&conn->istgt->mutex);
! 2113:
! 2114: /* check existing session */
! 2115: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 2116: "isid=%"PRIx64", tsih=%u, cid=%u\n",
! 2117: isid, tsih, cid);
! 2118: if (tsih != 0) {
! 2119: /* multiple connections */
! 2120: rc = istgt_append_sess(conn, isid, tsih, cid);
! 2121: if (rc < 0) {
! 2122: ISTGT_ERRLOG("isid=%"PRIx64", tsih=%u, cid=%u: "
! 2123: "append_sess() failed\n",
! 2124: isid, tsih, cid);
! 2125: /* Can't include in session */
! 2126: StatusClass = 0x02;
! 2127: StatusDetail = 0x08;
! 2128: goto response;
! 2129: }
! 2130: } else {
! 2131: /* new session, drop old sess by the initiator */
! 2132: istgt_iscsi_drop_old_conns(conn);
! 2133: }
! 2134:
! 2135: /* force target flags */
! 2136: MTX_LOCK(&lu->mutex);
! 2137: if (lu->no_auth_chap) {
! 2138: conn->req_auth = 0;
! 2139: rc = istgt_iscsi_param_del(&conn->params,
! 2140: "AuthMethod");
! 2141: if (rc < 0) {
! 2142: MTX_UNLOCK(&lu->mutex);
! 2143: ISTGT_ERRLOG("iscsi_param_del() failed\n");
! 2144: goto error_return;
! 2145: }
! 2146: rc = istgt_iscsi_param_add(&conn->params,
! 2147: "AuthMethod", "None", "None", ISPT_LIST);
! 2148: if (rc < 0) {
! 2149: MTX_UNLOCK(&lu->mutex);
! 2150: ISTGT_ERRLOG("iscsi_param_add() failed\n");
! 2151: goto error_return;
! 2152: }
! 2153: } else if (lu->auth_chap) {
! 2154: conn->req_auth = 1;
! 2155: rc = istgt_iscsi_param_del(&conn->params,
! 2156: "AuthMethod");
! 2157: if (rc < 0) {
! 2158: MTX_UNLOCK(&lu->mutex);
! 2159: ISTGT_ERRLOG("iscsi_param_del() failed\n");
! 2160: goto error_return;
! 2161: }
! 2162: rc = istgt_iscsi_param_add(&conn->params,
! 2163: "AuthMethod", "CHAP", "CHAP", ISPT_LIST);
! 2164: if (rc < 0) {
! 2165: MTX_UNLOCK(&lu->mutex);
! 2166: ISTGT_ERRLOG("iscsi_param_add() failed\n");
! 2167: goto error_return;
! 2168: }
! 2169: }
! 2170: if (lu->auth_chap_mutual) {
! 2171: conn->req_mutual = 1;
! 2172: }
! 2173: if (lu->header_digest) {
! 2174: rc = istgt_iscsi_param_del(&conn->params,
! 2175: "HeaderDigest");
! 2176: if (rc < 0) {
! 2177: MTX_UNLOCK(&lu->mutex);
! 2178: ISTGT_ERRLOG("iscsi_param_del() failed\n");
! 2179: goto error_return;
! 2180: }
! 2181: rc = istgt_iscsi_param_add(&conn->params,
! 2182: "HeaderDigest", "CRC32C", "CRC32C",
! 2183: ISPT_LIST);
! 2184: if (rc < 0) {
! 2185: MTX_UNLOCK(&lu->mutex);
! 2186: ISTGT_ERRLOG("iscsi_param_add() failed\n");
! 2187: goto error_return;
! 2188: }
! 2189: }
! 2190: if (lu->data_digest) {
! 2191: rc = istgt_iscsi_param_del(&conn->params,
! 2192: "DataDigest");
! 2193: if (rc < 0) {
! 2194: MTX_UNLOCK(&lu->mutex);
! 2195: ISTGT_ERRLOG("iscsi_param_del() failed\n");
! 2196: goto error_return;
! 2197: }
! 2198: rc = istgt_iscsi_param_add(&conn->params,
! 2199: "DataDigest", "CRC32C", "CRC32C",
! 2200: ISPT_LIST);
! 2201: if (rc < 0) {
! 2202: MTX_UNLOCK(&lu->mutex);
! 2203: ISTGT_ERRLOG("iscsi_param_add() failed\n");
! 2204: goto error_return;
! 2205: }
! 2206: }
! 2207: MTX_UNLOCK(&lu->mutex);
! 2208: } else if (strcasecmp(session_type, "Discovery") == 0) {
! 2209: snprintf(conn->target_name, sizeof conn->target_name,
! 2210: "%s", "dummy");
! 2211: snprintf(conn->target_port, sizeof conn->target_port,
! 2212: "%s" ",t,0x" "%4.4x", "dummy", conn->portal.tag);
! 2213: lu = NULL;
! 2214: tsih = 0;
! 2215:
! 2216: /* force target flags */
! 2217: MTX_LOCK(&conn->istgt->mutex);
! 2218: if (conn->istgt->no_discovery_auth) {
! 2219: conn->req_auth = 0;
! 2220: rc = istgt_iscsi_param_del(&conn->params,
! 2221: "AuthMethod");
! 2222: if (rc < 0) {
! 2223: MTX_UNLOCK(&conn->istgt->mutex);
! 2224: ISTGT_ERRLOG("iscsi_param_del() failed\n");
! 2225: goto error_return;
! 2226: }
! 2227: rc = istgt_iscsi_param_add(&conn->params,
! 2228: "AuthMethod", "None", "None", ISPT_LIST);
! 2229: if (rc < 0) {
! 2230: MTX_UNLOCK(&conn->istgt->mutex);
! 2231: ISTGT_ERRLOG("iscsi_param_add() failed\n");
! 2232: goto error_return;
! 2233: }
! 2234: } else if (conn->istgt->req_discovery_auth) {
! 2235: conn->req_auth = 1;
! 2236: rc = istgt_iscsi_param_del(&conn->params,
! 2237: "AuthMethod");
! 2238: if (rc < 0) {
! 2239: MTX_UNLOCK(&conn->istgt->mutex);
! 2240: ISTGT_ERRLOG("iscsi_param_del() failed\n");
! 2241: goto error_return;
! 2242: }
! 2243: rc = istgt_iscsi_param_add(&conn->params,
! 2244: "AuthMethod", "CHAP", "CHAP", ISPT_LIST);
! 2245: if (rc < 0) {
! 2246: MTX_UNLOCK(&conn->istgt->mutex);
! 2247: ISTGT_ERRLOG("iscsi_param_add() failed\n");
! 2248: goto error_return;
! 2249: }
! 2250: }
! 2251: if (conn->istgt->req_discovery_auth_mutual) {
! 2252: conn->req_mutual = 1;
! 2253: }
! 2254: MTX_UNLOCK(&conn->istgt->mutex);
! 2255: } else {
! 2256: ISTGT_ERRLOG("unknown session type\n");
! 2257: /* Missing parameter */
! 2258: StatusClass = 0x02;
! 2259: StatusDetail = 0x07;
! 2260: goto response;
! 2261: }
! 2262: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Target name: %s\n",
! 2263: conn->target_name);
! 2264: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Target port: %s\n",
! 2265: conn->target_port);
! 2266:
! 2267: conn->authenticated = 0;
! 2268: conn->auth.chap_phase = ISTGT_CHAP_PHASE_WAIT_A;
! 2269: conn->cid = cid;
! 2270: if (lu == NULL || lu->queue_depth == 0) {
! 2271: conn->queue_depth = ISCMDQ;
! 2272: } else {
! 2273: conn->queue_depth = lu->queue_depth;
! 2274: }
! 2275: conn->max_pending = (conn->queue_depth + 1) * 2;
! 2276: #if 0
! 2277: /* override config setting */
! 2278: MTX_LOCK(&conn->r2t_mutex);
! 2279: if ((conn->max_r2t > 0)
! 2280: && (conn->max_r2t < conn->max_pending)) {
! 2281: int i;
! 2282: xfree(conn->r2t_tasks);
! 2283: conn->max_r2t = conn->max_pending;
! 2284: conn->r2t_tasks = xmalloc (sizeof *conn->r2t_tasks
! 2285: * (conn->max_r2t + 1));
! 2286: for (i = 0; i < (conn->max_r2t + 1); i++) {
! 2287: conn->r2t_tasks[i] = NULL;
! 2288: }
! 2289: }
! 2290: MTX_UNLOCK(&conn->r2t_mutex);
! 2291: #endif
! 2292: if (conn->sess == NULL) {
! 2293: /* new session */
! 2294: rc = istgt_create_sess(conn->istgt, conn, lu);
! 2295: if (rc < 0) {
! 2296: ISTGT_ERRLOG("create_sess() failed\n");
! 2297: goto error_return;
! 2298: }
! 2299:
! 2300: /* initialize parameters */
! 2301: conn->StatSN = ExpStatSN;
! 2302: SESS_MTX_LOCK(conn);
! 2303: conn->MaxOutstandingR2T
! 2304: = conn->sess->MaxOutstandingR2T;
! 2305: conn->sess->isid = isid;
! 2306: conn->sess->tsih = tsih;
! 2307: conn->sess->lu = lu;
! 2308: conn->sess->ExpCmdSN = CmdSN;
! 2309: conn->sess->MaxCmdSN = CmdSN + conn->queue_depth - 1;
! 2310: SESS_MTX_UNLOCK(conn);
! 2311: }
! 2312:
! 2313: /* limit conns on discovery session */
! 2314: if (strcasecmp(session_type, "Discovery") == 0) {
! 2315: SESS_MTX_LOCK(conn);
! 2316: conn->sess->MaxConnections = 1;
! 2317: rc = istgt_iscsi_param_set_int(conn->sess->params,
! 2318: "MaxConnections", conn->sess->MaxConnections);
! 2319: SESS_MTX_UNLOCK(conn);
! 2320: if (rc < 0) {
! 2321: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 2322: goto error_return;
! 2323: }
! 2324: }
! 2325:
! 2326: /* declarative parameters */
! 2327: if (lu != NULL) {
! 2328: MTX_LOCK(&lu->mutex);
! 2329: if (lu->alias != NULL) {
! 2330: snprintf(buf, sizeof buf, "%s", lu->alias);
! 2331: } else {
! 2332: snprintf(buf, sizeof buf, "%s", "");
! 2333: }
! 2334: MTX_UNLOCK(&lu->mutex);
! 2335: SESS_MTX_LOCK(conn);
! 2336: rc = istgt_iscsi_param_set(conn->sess->params,
! 2337: "TargetAlias", buf);
! 2338: SESS_MTX_UNLOCK(conn);
! 2339: if (rc < 0) {
! 2340: ISTGT_ERRLOG("iscsi_param_set() failed\n");
! 2341: goto error_return;
! 2342: }
! 2343: }
! 2344: snprintf(buf, sizeof buf, "%s:%s,%d",
! 2345: conn->portal.host, conn->portal.port, conn->portal.tag);
! 2346: SESS_MTX_LOCK(conn);
! 2347: rc = istgt_iscsi_param_set(conn->sess->params,
! 2348: "TargetAddress", buf);
! 2349: SESS_MTX_UNLOCK(conn);
! 2350: if (rc < 0) {
! 2351: ISTGT_ERRLOG("iscsi_param_set() failed\n");
! 2352: goto error_return;
! 2353: }
! 2354: snprintf(buf, sizeof buf, "%d", conn->portal.tag);
! 2355: SESS_MTX_LOCK(conn);
! 2356: rc = istgt_iscsi_param_set(conn->sess->params,
! 2357: "TargetPortalGroupTag", buf);
! 2358: SESS_MTX_UNLOCK(conn);
! 2359: if (rc < 0) {
! 2360: ISTGT_ERRLOG("iscsi_param_set() failed\n");
! 2361: goto error_return;
! 2362: }
! 2363:
! 2364: /* write in response */
! 2365: if (lu != NULL) {
! 2366: SESS_MTX_LOCK(conn);
! 2367: val = ISCSI_GETVAL(conn->sess->params, "TargetAlias");
! 2368: if (val != NULL && strlen(val) != 0) {
! 2369: data_len = istgt_iscsi_append_param(conn,
! 2370: "TargetAlias", data, alloc_len, data_len);
! 2371: }
! 2372: if (strcasecmp(session_type, "Discovery") == 0) {
! 2373: data_len = istgt_iscsi_append_param(conn,
! 2374: "TargetAddress", data, alloc_len, data_len);
! 2375: }
! 2376: data_len = istgt_iscsi_append_param(conn,
! 2377: "TargetPortalGroupTag", data, alloc_len, data_len);
! 2378: SESS_MTX_UNLOCK(conn);
! 2379: }
! 2380:
! 2381: /* start login phase */
! 2382: conn->login_phase = ISCSI_LOGIN_PHASE_START;
! 2383: }
! 2384:
! 2385: /* negotiate parameters */
! 2386: data_len = istgt_iscsi_negotiate_params(conn, params,
! 2387: data, alloc_len, data_len);
! 2388: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "Negotiated Params",
! 2389: data, data_len);
! 2390:
! 2391: switch (CSG) {
! 2392: case 0:
! 2393: /* SecurityNegotiation */
! 2394: auth_method = ISCSI_GETVAL(conn->params, "AuthMethod");
! 2395: if (auth_method == NULL) {
! 2396: ISTGT_ERRLOG("AuthMethod is empty\n");
! 2397: /* Missing parameter */
! 2398: StatusClass = 0x02;
! 2399: StatusDetail = 0x07;
! 2400: goto response;
! 2401: }
! 2402: if (strcasecmp(auth_method, "None") == 0) {
! 2403: conn->authenticated = 1;
! 2404: } else {
! 2405: rc = istgt_iscsi_auth_params(conn, params, auth_method,
! 2406: data, alloc_len, data_len);
! 2407: if (rc < 0) {
! 2408: ISTGT_ERRLOG("iscsi_auth_params() failed\n");
! 2409: /* Authentication failure */
! 2410: StatusClass = 0x02;
! 2411: StatusDetail = 0x01;
! 2412: goto response;
! 2413: }
! 2414: data_len = rc;
! 2415: if (conn->authenticated == 0) {
! 2416: /* not complete */
! 2417: T_bit = 0;
! 2418: } else {
! 2419: if (conn->auth.chap_phase != ISTGT_CHAP_PHASE_END) {
! 2420: ISTGT_WARNLOG("CHAP phase not complete");
! 2421: }
! 2422: }
! 2423: #if 0
! 2424: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG,
! 2425: "Negotiated Auth Params", data, data_len);
! 2426: #endif
! 2427: }
! 2428: break;
! 2429: case 1:
! 2430: /* LoginOperationalNegotiation */
! 2431: if (conn->login_phase == ISCSI_LOGIN_PHASE_START) {
! 2432: if (conn->req_auth) {
! 2433: /* Authentication failure */
! 2434: StatusClass = 0x02;
! 2435: StatusDetail = 0x01;
! 2436: goto response;
! 2437: } else {
! 2438: /* AuthMethod=None */
! 2439: conn->authenticated = 1;
! 2440: }
! 2441: }
! 2442: if (conn->authenticated == 0) {
! 2443: ISTGT_ERRLOG("authentication error\n");
! 2444: /* Authentication failure */
! 2445: StatusClass = 0x02;
! 2446: StatusDetail = 0x01;
! 2447: goto response;
! 2448: }
! 2449: break;
! 2450: case 3:
! 2451: /* FullFeaturePhase */
! 2452: ISTGT_ERRLOG("XXX Login in FullFeaturePhase\n");
! 2453: /* Initiator error */
! 2454: StatusClass = 0x02;
! 2455: StatusDetail = 0x00;
! 2456: goto response;
! 2457: default:
! 2458: ISTGT_ERRLOG("unknown stage\n");
! 2459: /* Initiator error */
! 2460: StatusClass = 0x02;
! 2461: StatusDetail = 0x00;
! 2462: goto response;
! 2463: }
! 2464:
! 2465: if (T_bit) {
! 2466: switch (NSG) {
! 2467: case 0:
! 2468: /* SecurityNegotiation */
! 2469: conn->login_phase = ISCSI_LOGIN_PHASE_SECURITY;
! 2470: break;
! 2471: case 1:
! 2472: /* LoginOperationalNegotiation */
! 2473: conn->login_phase = ISCSI_LOGIN_PHASE_OPERATIONAL;
! 2474: break;
! 2475: case 3:
! 2476: /* FullFeaturePhase */
! 2477: conn->login_phase = ISCSI_LOGIN_PHASE_FULLFEATURE;
! 2478:
! 2479: SESS_MTX_LOCK(conn);
! 2480: if (ISCSI_EQVAL(conn->sess->params, "SessionType", "Normal")) {
! 2481: /* normal session */
! 2482: tsih = conn->sess->tsih;
! 2483: /* new tsih? */
! 2484: if (tsih == 0) {
! 2485: tsih = istgt_lu_allocate_tsih(conn->sess->lu,
! 2486: conn->initiator_port,
! 2487: conn->portal.tag);
! 2488: if (tsih == 0) {
! 2489: SESS_MTX_UNLOCK(conn);
! 2490: ISTGT_ERRLOG("lu_allocate_tsih() failed\n");
! 2491: goto error_return;
! 2492: }
! 2493: conn->sess->tsih = tsih;
! 2494: } else {
! 2495: /* multiple connection */
! 2496: }
! 2497:
! 2498: snprintf(buf, sizeof buf, "Login from %s (%s) on %s LU%d"
! 2499: " (%s:%s,%d), ISID=%"PRIx64", TSIH=%u,"
! 2500: " CID=%u, HeaderDigest=%s, DataDigest=%s\n",
! 2501: conn->initiator_name, conn->initiator_addr,
! 2502: conn->target_name, conn->sess->lu->num,
! 2503: conn->portal.host, conn->portal.port,
! 2504: conn->portal.tag,
! 2505: conn->sess->isid, conn->sess->tsih, conn->cid,
! 2506: (ISCSI_EQVAL(conn->params, "HeaderDigest", "CRC32C")
! 2507: ? "on" : "off"),
! 2508: (ISCSI_EQVAL(conn->params, "DataDigest", "CRC32C")
! 2509: ? "on" : "off"));
! 2510: ISTGT_NOTICELOG("%s", buf);
! 2511: } else if (ISCSI_EQVAL(conn->sess->params, "SessionType", "Discovery")) {
! 2512: /* discovery session */
! 2513: /* new tsih */
! 2514: MTX_LOCK(&g_last_tsih_mutex);
! 2515: tsih = conn->sess->tsih;
! 2516: g_last_tsih++;
! 2517: tsih = g_last_tsih;
! 2518: if (tsih == 0) {
! 2519: g_last_tsih++;
! 2520: tsih = g_last_tsih;
! 2521: }
! 2522: conn->sess->tsih = tsih;
! 2523: MTX_UNLOCK(&g_last_tsih_mutex);
! 2524:
! 2525: snprintf(buf, sizeof buf, "Login(discovery) from %s (%s) on"
! 2526: " (%s:%s,%d), ISID=%"PRIx64", TSIH=%u,"
! 2527: " CID=%u, HeaderDigest=%s, DataDigest=%s\n",
! 2528: conn->initiator_name, conn->initiator_addr,
! 2529: conn->portal.host, conn->portal.port,
! 2530: conn->portal.tag,
! 2531: conn->sess->isid, conn->sess->tsih, conn->cid,
! 2532: (ISCSI_EQVAL(conn->params, "HeaderDigest", "CRC32C")
! 2533: ? "on" : "off"),
! 2534: (ISCSI_EQVAL(conn->params, "DataDigest", "CRC32C")
! 2535: ? "on" : "off"));
! 2536: ISTGT_NOTICELOG("%s", buf);
! 2537: } else {
! 2538: ISTGT_ERRLOG("unknown session type\n");
! 2539: SESS_MTX_UNLOCK(conn);
! 2540: /* Initiator error */
! 2541: StatusClass = 0x02;
! 2542: StatusDetail = 0x00;
! 2543: goto response;
! 2544: }
! 2545: SESS_MTX_UNLOCK(conn);
! 2546:
! 2547: conn->full_feature = 1;
! 2548: break;
! 2549: default:
! 2550: ISTGT_ERRLOG("unknown stage\n");
! 2551: /* Initiator error */
! 2552: StatusClass = 0x02;
! 2553: StatusDetail = 0x00;
! 2554: goto response;
! 2555: }
! 2556: }
! 2557:
! 2558: response:
! 2559: /* response PDU */
! 2560: rsp = (uint8_t *) &rsp_pdu.bhs;
! 2561: rsp_pdu.data = data;
! 2562: memset(rsp, 0, ISCSI_BHS_LEN);
! 2563: rsp[0] = ISCSI_OP_LOGIN_RSP;
! 2564: BDADD8(&rsp[1], T_bit, 7);
! 2565: BDADD8(&rsp[1], C_bit, 6);
! 2566: BDADD8W(&rsp[1], CSG, 3, 2);
! 2567: BDADD8W(&rsp[1], NSG, 1, 2);
! 2568: rsp[2] = ISCSI_VERSION; // Version-max
! 2569: rsp[3] = ISCSI_VERSION; // Version-active
! 2570: rsp[4] = 0; // TotalAHSLength
! 2571: DSET24(&rsp[5], data_len); // DataSegmentLength
! 2572:
! 2573: DSET48(&rsp[8], isid);
! 2574: DSET16(&rsp[14], tsih);
! 2575: DSET32(&rsp[16], task_tag);
! 2576:
! 2577: DSET32(&rsp[24], conn->StatSN);
! 2578: conn->StatSN++;
! 2579: if (conn->sess != NULL) {
! 2580: SESS_MTX_LOCK(conn);
! 2581: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 2582: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 2583: SESS_MTX_UNLOCK(conn);
! 2584: } else {
! 2585: DSET32(&rsp[28], CmdSN);
! 2586: DSET32(&rsp[32], CmdSN);
! 2587: }
! 2588:
! 2589: rsp[36] = StatusClass;
! 2590: rsp[37] = StatusDetail;
! 2591:
! 2592: #if 1
! 2593: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "PDU", rsp, ISCSI_BHS_LEN);
! 2594: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "DATA", data, data_len);
! 2595: #endif
! 2596: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 2597: if (rc < 0) {
! 2598: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 2599: istgt_iscsi_param_free(params);
! 2600: xfree(data);
! 2601: return -1;
! 2602: }
! 2603:
! 2604: /* after send PDU digest on/off */
! 2605: if (conn->full_feature) {
! 2606: /* update internal variables */
! 2607: istgt_iscsi_copy_param2var(conn);
! 2608: /* check value */
! 2609: rc = istgt_iscsi_check_values(conn);
! 2610: if (rc < 0) {
! 2611: ISTGT_ERRLOG("iscsi_check_values() failed\n");
! 2612: istgt_iscsi_param_free(params);
! 2613: xfree(data);
! 2614: return -1;
! 2615: }
! 2616: }
! 2617:
! 2618: istgt_iscsi_param_free(params);
! 2619: xfree(data);
! 2620: return 0;
! 2621: }
! 2622:
! 2623: static int
! 2624: istgt_iscsi_op_text(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 2625: {
! 2626: ISCSI_PARAM *params = NULL;
! 2627: ISCSI_PDU rsp_pdu;
! 2628: uint8_t *rsp;
! 2629: uint8_t *cp;
! 2630: uint8_t *data;
! 2631: uint64_t lun;
! 2632: uint32_t task_tag;
! 2633: uint32_t transfer_tag;
! 2634: uint32_t CmdSN;
! 2635: uint32_t ExpStatSN;
! 2636: const char *iiqn;
! 2637: const char *val;
! 2638: int I_bit, F_bit, C_bit;
! 2639: int data_len;
! 2640: int alloc_len;
! 2641: int rc;
! 2642:
! 2643: if (!conn->full_feature) {
! 2644: ISTGT_ERRLOG("before Full Feature\n");
! 2645: return -1;
! 2646: }
! 2647:
! 2648: data_len = 0;
! 2649: alloc_len = conn->sendbufsize;
! 2650: data = (uint8_t *) conn->sendbuf;
! 2651: memset(data, 0, alloc_len);
! 2652:
! 2653: cp = (uint8_t *) &pdu->bhs;
! 2654: I_bit = BGET8(&cp[0], 7);
! 2655: F_bit = BGET8(&cp[1], 7);
! 2656: C_bit = BGET8(&cp[1], 6);
! 2657:
! 2658: lun = DGET64(&cp[8]);
! 2659: task_tag = DGET32(&cp[16]);
! 2660: transfer_tag = DGET32(&cp[20]);
! 2661: CmdSN = DGET32(&cp[24]);
! 2662: ExpStatSN = DGET32(&cp[28]);
! 2663:
! 2664: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 2665: "I=%d, F=%d, C=%d, ITT=%x, TTT=%x\n",
! 2666: I_bit, F_bit, C_bit, task_tag, transfer_tag);
! 2667: SESS_MTX_LOCK(conn);
! 2668: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 2669: "CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 2670: CmdSN, ExpStatSN, conn->StatSN, conn->sess->ExpCmdSN,
! 2671: conn->sess->MaxCmdSN);
! 2672: if (I_bit == 0) {
! 2673: if (SN32_LT(CmdSN, conn->sess->ExpCmdSN)
! 2674: || SN32_GT(CmdSN, conn->sess->MaxCmdSN)) {
! 2675: ISTGT_ERRLOG("CmdSN(%u) ignore (ExpCmdSN=%u, MaxCmdSN=%u)\n",
! 2676: CmdSN, conn->sess->ExpCmdSN,
! 2677: conn->sess->MaxCmdSN);
! 2678: SESS_MTX_UNLOCK(conn);
! 2679: return -1;
! 2680: }
! 2681: } else if (CmdSN != conn->sess->ExpCmdSN) {
! 2682: SESS_MTX_UNLOCK(conn);
! 2683: ISTGT_ERRLOG("CmdSN(%u) error\n", CmdSN);
! 2684: return -1;
! 2685: }
! 2686: SESS_MTX_UNLOCK(conn);
! 2687: if (SN32_GT(ExpStatSN, conn->StatSN)) {
! 2688: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "StatSN(%u) advanced\n",
! 2689: ExpStatSN);
! 2690: conn->StatSN = ExpStatSN;
! 2691: }
! 2692: if (ExpStatSN != conn->StatSN) {
! 2693: #if 0
! 2694: ISTGT_ERRLOG("StatSN(%u) error\n", ExpStatSN);
! 2695: return -1;
! 2696: #else
! 2697: /* StarPort have a bug */
! 2698: ISTGT_WARNLOG("StatSN(%u) rewound\n", ExpStatSN);
! 2699: conn->StatSN = ExpStatSN;
! 2700: #endif
! 2701: }
! 2702:
! 2703: if (F_bit && C_bit) {
! 2704: ISTGT_ERRLOG("final and continue\n");
! 2705: return -1;
! 2706: }
! 2707:
! 2708: /* store incoming parameters */
! 2709: rc = istgt_iscsi_parse_params(¶ms, pdu->data,
! 2710: pdu->data_segment_len);
! 2711: if (rc < 0) {
! 2712: ISTGT_ERRLOG("iscsi_parse_params() failed\n");
! 2713: istgt_iscsi_param_free(params);
! 2714: return -1;
! 2715: }
! 2716:
! 2717: /* negotiate parameters */
! 2718: data_len = istgt_iscsi_negotiate_params(conn, params,
! 2719: data, alloc_len, data_len);
! 2720: /* sendtargets is special case */
! 2721: val = ISCSI_GETVAL(params, "SendTargets");
! 2722: if (val != NULL) {
! 2723: if (strcasecmp(val, "") == 0) {
! 2724: val = conn->target_name;
! 2725: }
! 2726: SESS_MTX_LOCK(conn);
! 2727: iiqn = ISCSI_GETVAL(conn->sess->params,
! 2728: "InitiatorName");
! 2729: if (ISCSI_EQVAL(conn->sess->params,
! 2730: "SessionType", "Discovery")) {
! 2731: data_len = istgt_lu_sendtargets(conn,
! 2732: conn->initiator_name,
! 2733: conn->initiator_addr,
! 2734: val, data, alloc_len, data_len);
! 2735: } else {
! 2736: if (strcasecmp(val, "ALL") == 0) {
! 2737: /* not in discovery session */
! 2738: data_len = istgt_iscsi_append_text(conn, "SendTargets",
! 2739: "Reject", data, alloc_len, data_len);
! 2740: } else {
! 2741: data_len = istgt_lu_sendtargets(conn,
! 2742: conn->initiator_name,
! 2743: conn->initiator_addr,
! 2744: val, data, alloc_len, data_len);
! 2745: }
! 2746: }
! 2747: SESS_MTX_UNLOCK(conn);
! 2748: }
! 2749: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "Negotiated Params",
! 2750: data, data_len);
! 2751:
! 2752: /* response PDU */
! 2753: rsp = (uint8_t *) &rsp_pdu.bhs;
! 2754: rsp_pdu.data = data;
! 2755: memset(rsp, 0, ISCSI_BHS_LEN);
! 2756: rsp[0] = ISCSI_OP_TEXT_RSP;
! 2757: BDADD8(&rsp[1], F_bit, 7);
! 2758: BDADD8(&rsp[1], C_bit, 6);
! 2759: rsp[4] = 0; // TotalAHSLength
! 2760: DSET24(&rsp[5], data_len); // DataSegmentLength
! 2761:
! 2762: DSET64(&rsp[8], lun);
! 2763: DSET32(&rsp[16], task_tag);
! 2764: if (F_bit) {
! 2765: DSET32(&rsp[20], 0xffffffffU);
! 2766: } else {
! 2767: transfer_tag = 1 + conn->id;
! 2768: DSET32(&rsp[20], transfer_tag);
! 2769: }
! 2770:
! 2771: DSET32(&rsp[24], conn->StatSN);
! 2772: conn->StatSN++;
! 2773: SESS_MTX_LOCK(conn);
! 2774: if (I_bit == 0) {
! 2775: conn->sess->ExpCmdSN++;
! 2776: conn->sess->MaxCmdSN++;
! 2777: }
! 2778: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 2779: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 2780: SESS_MTX_UNLOCK(conn);
! 2781:
! 2782: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 2783: if (rc < 0) {
! 2784: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 2785: istgt_iscsi_param_free(params);
! 2786: return -1;
! 2787: }
! 2788:
! 2789: /* update internal variables */
! 2790: istgt_iscsi_copy_param2var(conn);
! 2791: /* check value */
! 2792: rc = istgt_iscsi_check_values(conn);
! 2793: if (rc < 0) {
! 2794: ISTGT_ERRLOG("iscsi_check_values() failed\n");
! 2795: istgt_iscsi_param_free(params);
! 2796: return -1;
! 2797: }
! 2798:
! 2799: istgt_iscsi_param_free(params);
! 2800: return 0;
! 2801: }
! 2802:
! 2803: static int
! 2804: istgt_iscsi_op_logout(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 2805: {
! 2806: char buf[MAX_TMPBUF];
! 2807: ISCSI_PDU rsp_pdu;
! 2808: uint8_t *rsp;
! 2809: uint8_t *cp;
! 2810: uint8_t *data;
! 2811: uint32_t task_tag;
! 2812: uint16_t cid;
! 2813: uint32_t CmdSN;
! 2814: uint32_t ExpStatSN;
! 2815: int reason;
! 2816: int response;
! 2817: int data_len;
! 2818: int alloc_len;
! 2819: int rc;
! 2820:
! 2821: data_len = 0;
! 2822: alloc_len = conn->sendbufsize;
! 2823: data = (uint8_t *) conn->sendbuf;
! 2824: memset(data, 0, alloc_len);
! 2825:
! 2826: cp = (uint8_t *) &pdu->bhs;
! 2827: reason = BGET8W(&cp[1], 6, 7);
! 2828:
! 2829: task_tag = DGET32(&cp[16]);
! 2830: cid = DGET16(&cp[20]);
! 2831: CmdSN = DGET32(&cp[24]);
! 2832: ExpStatSN = DGET32(&cp[28]);
! 2833:
! 2834: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 2835: "reason=%d, ITT=%x, cid=%d\n",
! 2836: reason, task_tag, cid);
! 2837: if (conn->sess != NULL) {
! 2838: SESS_MTX_LOCK(conn);
! 2839: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 2840: "CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 2841: CmdSN, ExpStatSN, conn->StatSN, conn->sess->ExpCmdSN,
! 2842: conn->sess->MaxCmdSN);
! 2843: if (CmdSN != conn->sess->ExpCmdSN) {
! 2844: ISTGT_WARNLOG("CmdSN(%u) might have dropped\n", CmdSN);
! 2845: /* ignore error */
! 2846: }
! 2847: SESS_MTX_UNLOCK(conn);
! 2848: } else {
! 2849: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 2850: "CmdSN=%u, ExpStatSN=%u, StatSN=%u\n",
! 2851: CmdSN, ExpStatSN, conn->StatSN);
! 2852: }
! 2853: if (SN32_GT(ExpStatSN, conn->StatSN)) {
! 2854: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "StatSN(%u) advanced\n",
! 2855: ExpStatSN);
! 2856: conn->StatSN = ExpStatSN;
! 2857: }
! 2858: if (ExpStatSN != conn->StatSN) {
! 2859: ISTGT_WARNLOG("StatSN(%u/%u) might have dropped\n",
! 2860: ExpStatSN, conn->StatSN);
! 2861: /* ignore error */
! 2862: }
! 2863:
! 2864: response = 0; // connection or session closed successfully
! 2865:
! 2866: /* response PDU */
! 2867: rsp = (uint8_t *) &rsp_pdu.bhs;
! 2868: rsp_pdu.data = data;
! 2869: memset(rsp, 0, ISCSI_BHS_LEN);
! 2870: rsp[0] = ISCSI_OP_LOGOUT_RSP;
! 2871: BDADD8W(&rsp[1], 1, 7, 1);
! 2872: rsp[2] = response;
! 2873: rsp[4] = 0; // TotalAHSLength
! 2874: DSET24(&rsp[5], data_len); // DataSegmentLength
! 2875:
! 2876: DSET32(&rsp[16], task_tag);
! 2877:
! 2878: DSET32(&rsp[24], conn->StatSN);
! 2879: conn->StatSN++;
! 2880: if (conn->sess != NULL) {
! 2881: SESS_MTX_LOCK(conn);
! 2882: if (conn->sess->connections == 1) {
! 2883: conn->sess->ExpCmdSN++;
! 2884: conn->sess->MaxCmdSN++;
! 2885: }
! 2886: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 2887: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 2888: SESS_MTX_UNLOCK(conn);
! 2889: } else {
! 2890: DSET32(&rsp[28], CmdSN);
! 2891: DSET32(&rsp[32], CmdSN);
! 2892: }
! 2893:
! 2894: DSET16(&rsp[40], 0); // Time2Wait
! 2895: DSET16(&rsp[42], 0); // Time2Retain
! 2896:
! 2897: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 2898: if (rc < 0) {
! 2899: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 2900: return -1;
! 2901: }
! 2902:
! 2903: SESS_MTX_LOCK(conn);
! 2904: if (ISCSI_EQVAL(conn->sess->params, "SessionType", "Normal")) {
! 2905: snprintf(buf, sizeof buf, "Logout from %s (%s) on %s LU%d"
! 2906: " (%s:%s,%d), ISID=%"PRIx64", TSIH=%u,"
! 2907: " CID=%u, HeaderDigest=%s, DataDigest=%s\n",
! 2908: conn->initiator_name, conn->initiator_addr,
! 2909: conn->target_name, conn->sess->lu->num,
! 2910: conn->portal.host, conn->portal.port, conn->portal.tag,
! 2911: conn->sess->isid, conn->sess->tsih, conn->cid,
! 2912: (ISCSI_EQVAL(conn->params, "HeaderDigest", "CRC32C")
! 2913: ? "on" : "off"),
! 2914: (ISCSI_EQVAL(conn->params, "DataDigest", "CRC32C")
! 2915: ? "on" : "off"));
! 2916: ISTGT_NOTICELOG("%s", buf);
! 2917: } else {
! 2918: /* discovery session */
! 2919: snprintf(buf, sizeof buf, "Logout(discovery) from %s (%s) on"
! 2920: " (%s:%s,%d), ISID=%"PRIx64", TSIH=%u,"
! 2921: " CID=%u, HeaderDigest=%s, DataDigest=%s\n",
! 2922: conn->initiator_name, conn->initiator_addr,
! 2923: conn->portal.host, conn->portal.port, conn->portal.tag,
! 2924: conn->sess->isid, conn->sess->tsih, conn->cid,
! 2925: (ISCSI_EQVAL(conn->params, "HeaderDigest", "CRC32C")
! 2926: ? "on" : "off"),
! 2927: (ISCSI_EQVAL(conn->params, "DataDigest", "CRC32C")
! 2928: ? "on" : "off"));
! 2929: ISTGT_NOTICELOG("%s", buf);
! 2930: }
! 2931: SESS_MTX_UNLOCK(conn);
! 2932:
! 2933: conn->exec_logout = 1;
! 2934: return 0;
! 2935: }
! 2936:
! 2937: static int istgt_iscsi_transfer_in_internal(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd);
! 2938:
! 2939: static int
! 2940: istgt_iscsi_transfer_in(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
! 2941: {
! 2942: int rc;
! 2943:
! 2944: //MTX_LOCK(&conn->wpdu_mutex);
! 2945: rc = istgt_iscsi_transfer_in_internal(conn, lu_cmd);
! 2946: //MTX_UNLOCK(&conn->wpdu_mutex);
! 2947: return rc;
! 2948: }
! 2949:
! 2950: static int
! 2951: istgt_iscsi_transfer_in_internal(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
! 2952: {
! 2953: ISCSI_PDU rsp_pdu;
! 2954: uint8_t *rsp;
! 2955: uint8_t *data;
! 2956: uint32_t task_tag;
! 2957: uint32_t transfer_tag;
! 2958: uint32_t DataSN;
! 2959: int transfer_len;
! 2960: int data_len;
! 2961: int segment_len;
! 2962: int offset;
! 2963: int F_bit, O_bit, U_bit, S_bit;
! 2964: int residual_len;
! 2965: int sent_status;
! 2966: int len;
! 2967: int rc;
! 2968:
! 2969: data = lu_cmd->data;
! 2970: transfer_len = lu_cmd->transfer_len;
! 2971: data_len = lu_cmd->data_len;
! 2972: segment_len = conn->MaxRecvDataSegmentLength;
! 2973:
! 2974: F_bit = O_bit = U_bit = S_bit = 0;
! 2975: if (data_len < transfer_len) {
! 2976: /* underflow */
! 2977: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Underflow %u/%u\n",
! 2978: data_len, transfer_len);
! 2979: residual_len = transfer_len - data_len;
! 2980: transfer_len = data_len;
! 2981: U_bit = 1;
! 2982: } else if (data_len > transfer_len) {
! 2983: /* overflow */
! 2984: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Overflow %u/%u\n",
! 2985: data_len, transfer_len);
! 2986: residual_len = data_len - transfer_len;
! 2987: O_bit = 1;
! 2988: } else {
! 2989: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Transfer %u\n",
! 2990: transfer_len);
! 2991: residual_len = 0;
! 2992: }
! 2993:
! 2994: task_tag = lu_cmd->task_tag;
! 2995: transfer_tag = 0xffffffffU;
! 2996: DataSN = 0;
! 2997: sent_status = 0;
! 2998:
! 2999: /* send data splitted by segment_len */
! 3000: for (offset = 0; offset < transfer_len; offset += segment_len) {
! 3001: len = DMIN32(segment_len, (transfer_len - offset));
! 3002:
! 3003: if (offset + len > transfer_len) {
! 3004: ISTGT_ERRLOG("transfer missing\n");
! 3005: return -1;
! 3006: } else if (offset + len == transfer_len) {
! 3007: /* final PDU */
! 3008: F_bit = 1;
! 3009: S_bit = 0;
! 3010: if (lu_cmd->sense_data_len == 0
! 3011: && (lu_cmd->status == ISTGT_SCSI_STATUS_GOOD
! 3012: || lu_cmd->status == ISTGT_SCSI_STATUS_CONDITION_MET
! 3013: || lu_cmd->status == ISTGT_SCSI_STATUS_INTERMEDIATE
! 3014: || lu_cmd->status == ISTGT_SCSI_STATUS_INTERMEDIATE_CONDITION_MET)) {
! 3015: S_bit = 1;
! 3016: sent_status = 1;
! 3017: }
! 3018: } else {
! 3019: F_bit = 0;
! 3020: S_bit = 0;
! 3021: }
! 3022:
! 3023: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3024: "Transfer=%d, Offset=%d, Len=%d\n",
! 3025: transfer_len, offset, len);
! 3026: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 3027: "StatSN=%u, DataSN=%u, Offset=%u, Len=%d\n",
! 3028: conn->StatSN, DataSN, offset, len);
! 3029:
! 3030: /* DATA PDU */
! 3031: rsp = (uint8_t *) &rsp_pdu.bhs;
! 3032: rsp_pdu.data = data + offset;
! 3033: memset(rsp, 0, ISCSI_BHS_LEN);
! 3034: rsp[0] = ISCSI_OP_SCSI_DATAIN;
! 3035: BDADD8(&rsp[1], F_bit, 7);
! 3036: BDADD8(&rsp[1], 0, 6); // A_bit Acknowledge
! 3037: if (F_bit && S_bit) {
! 3038: BDADD8(&rsp[1], O_bit, 2);
! 3039: BDADD8(&rsp[1], U_bit, 1);
! 3040: } else {
! 3041: BDADD8(&rsp[1], 0, 2);
! 3042: BDADD8(&rsp[1], 0, 1);
! 3043: }
! 3044: BDADD8(&rsp[1], S_bit, 0);
! 3045: if (S_bit) {
! 3046: rsp[3] = lu_cmd->status;
! 3047: } else {
! 3048: rsp[3] = 0; // Status or Rsvd
! 3049: }
! 3050: rsp[4] = 0; // TotalAHSLength
! 3051: DSET24(&rsp[5], len); // DataSegmentLength
! 3052:
! 3053: DSET32(&rsp[16], task_tag);
! 3054: DSET32(&rsp[20], transfer_tag);
! 3055:
! 3056: if (S_bit) {
! 3057: DSET32(&rsp[24], conn->StatSN);
! 3058: conn->StatSN++;
! 3059: } else {
! 3060: DSET32(&rsp[24], 0); // StatSN or Reserved
! 3061: }
! 3062: SESS_MTX_LOCK(conn);
! 3063: if (F_bit && S_bit && lu_cmd->I_bit == 0) {
! 3064: conn->sess->MaxCmdSN++;
! 3065: }
! 3066: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 3067: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 3068: SESS_MTX_UNLOCK(conn);
! 3069:
! 3070: DSET32(&rsp[36], DataSN);
! 3071: DataSN++;
! 3072:
! 3073: DSET32(&rsp[40], (uint32_t) offset);
! 3074: if (F_bit && S_bit) {
! 3075: DSET32(&rsp[44], residual_len);
! 3076: } else {
! 3077: DSET32(&rsp[44], 0);
! 3078: }
! 3079:
! 3080: rc = istgt_iscsi_write_pdu_internal(conn, &rsp_pdu);
! 3081: if (rc < 0) {
! 3082: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 3083: return -1;
! 3084: }
! 3085: }
! 3086:
! 3087: if (sent_status) {
! 3088: return 1;
! 3089: }
! 3090: return 0;
! 3091: }
! 3092:
! 3093: static int
! 3094: istgt_iscsi_op_scsi(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 3095: {
! 3096: ISTGT_LU_CMD lu_cmd;
! 3097: ISCSI_PDU rsp_pdu;
! 3098: uint8_t *rsp;
! 3099: uint8_t *cp;
! 3100: uint8_t *data;
! 3101: uint8_t *cdb;
! 3102: uint64_t lun;
! 3103: uint32_t task_tag;
! 3104: uint32_t transfer_len;
! 3105: uint32_t CmdSN;
! 3106: uint32_t ExpStatSN;
! 3107: int I_bit, F_bit, R_bit, W_bit, Attr_bit;
! 3108: int o_bit, u_bit, O_bit, U_bit;
! 3109: int bidi_residual_len;
! 3110: int residual_len;
! 3111: int data_len;
! 3112: int alloc_len;
! 3113: int rc;
! 3114:
! 3115: if (!conn->full_feature) {
! 3116: ISTGT_ERRLOG("before Full Feature\n");
! 3117: return -1;
! 3118: }
! 3119:
! 3120: data_len = 0;
! 3121: alloc_len = conn->sendbufsize;
! 3122: data = (uint8_t *) conn->sendbuf;
! 3123: memset(data, 0, alloc_len);
! 3124: memset(&lu_cmd, 0, sizeof lu_cmd);
! 3125:
! 3126: cp = (uint8_t *) &pdu->bhs;
! 3127: I_bit = BGET8(&cp[0], 6);
! 3128: F_bit = BGET8(&cp[1], 7);
! 3129: R_bit = BGET8(&cp[1], 6);
! 3130: W_bit = BGET8(&cp[1], 5);
! 3131: Attr_bit = BGET8W(&cp[1], 2, 3);
! 3132:
! 3133: lun = DGET64(&cp[8]);
! 3134: task_tag = DGET32(&cp[16]);
! 3135: transfer_len = DGET32(&cp[20]);
! 3136: CmdSN = DGET32(&cp[24]);
! 3137: ExpStatSN = DGET32(&cp[28]);
! 3138:
! 3139: cdb = &cp[32];
! 3140: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "CDB", cdb, 16);
! 3141: #if 0
! 3142: ISTGT_TRACEDUMP(ISTGT_TRACE_DEBUG, "PDU", cp, ISCSI_BHS_LEN);
! 3143: #endif
! 3144:
! 3145: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3146: "I=%d, F=%d, R=%d, W=%d, Attr=%d, ITT=%x, TL=%u\n",
! 3147: I_bit, F_bit, R_bit, W_bit, Attr_bit,
! 3148: task_tag, transfer_len);
! 3149: SESS_MTX_LOCK(conn);
! 3150: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 3151: "CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 3152: CmdSN, ExpStatSN, conn->StatSN, conn->sess->ExpCmdSN,
! 3153: conn->sess->MaxCmdSN);
! 3154: if (I_bit == 0) {
! 3155: /* XXX MCS reverse order? */
! 3156: if (SN32_GT(CmdSN, conn->sess->ExpCmdSN)) {
! 3157: if (conn->sess->connections > 1) {
! 3158: struct timespec abstime;
! 3159: time_t now;
! 3160:
! 3161: SESS_MTX_UNLOCK(conn);
! 3162: now = time(NULL);
! 3163: memset(&abstime, 0, sizeof abstime);
! 3164: abstime.tv_sec = now + (MAX_MCSREVWAIT / 1000);
! 3165: abstime.tv_nsec = (MAX_MCSREVWAIT % 1000) * 1000000;
! 3166:
! 3167: rc = 0;
! 3168: SESS_MTX_LOCK(conn);
! 3169: while (SN32_GT(CmdSN, conn->sess->ExpCmdSN)) {
! 3170: conn->sess->req_mcs_cond++;
! 3171: rc = pthread_cond_timedwait(&conn->sess->mcs_cond,
! 3172: &conn->sess->mutex,
! 3173: &abstime);
! 3174: if (rc == ETIMEDOUT) {
! 3175: if (SN32_GT(CmdSN, conn->sess->ExpCmdSN)) {
! 3176: rc = -1;
! 3177: /* timeout */
! 3178: break;
! 3179: }
! 3180: /* OK cond */
! 3181: rc = 0;
! 3182: break;
! 3183: }
! 3184: if (rc != 0) {
! 3185: break;
! 3186: }
! 3187: }
! 3188: if (rc < 0) {
! 3189: ISTGT_ERRLOG("MCS: CmdSN(%u) error ExpCmdSN=%u\n",
! 3190: CmdSN, conn->sess->ExpCmdSN);
! 3191: SESS_MTX_UNLOCK(conn);
! 3192: return -1;
! 3193: }
! 3194: #if 0
! 3195: ISTGT_WARNLOG("MCS: reverse CmdSN=%u(retry=%d, yields=%d)\n",
! 3196: CmdSN, retry, try_yields);
! 3197: #endif
! 3198: }
! 3199: }
! 3200: }
! 3201:
! 3202: if (I_bit == 0) {
! 3203: if (SN32_LT(CmdSN, conn->sess->ExpCmdSN)
! 3204: || SN32_GT(CmdSN, conn->sess->MaxCmdSN)) {
! 3205: ISTGT_ERRLOG("CmdSN(%u) ignore (ExpCmdSN=%u, MaxCmdSN=%u)\n",
! 3206: CmdSN, conn->sess->ExpCmdSN,
! 3207: conn->sess->MaxCmdSN);
! 3208: SESS_MTX_UNLOCK(conn);
! 3209: return -1;
! 3210: }
! 3211: if (SN32_GT(CmdSN, conn->sess->ExpCmdSN)) {
! 3212: ISTGT_WARNLOG("CmdSN(%u) > ExpCmdSN(%u)\n",
! 3213: CmdSN, conn->sess->ExpCmdSN);
! 3214: conn->sess->ExpCmdSN = CmdSN;
! 3215: }
! 3216: } else if (CmdSN != conn->sess->ExpCmdSN) {
! 3217: SESS_MTX_UNLOCK(conn);
! 3218: ISTGT_ERRLOG("CmdSN(%u) error ExpCmdSN=%u\n",
! 3219: CmdSN, conn->sess->ExpCmdSN);
! 3220: return -1;
! 3221: }
! 3222: SESS_MTX_UNLOCK(conn);
! 3223: if (SN32_GT(ExpStatSN, conn->StatSN)) {
! 3224: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "StatSN(%u) advanced\n",
! 3225: ExpStatSN);
! 3226: conn->StatSN = ExpStatSN;
! 3227: }
! 3228: {
! 3229: uint32_t QCmdSN;
! 3230: SESS_MTX_LOCK(conn);
! 3231: QCmdSN = conn->sess->MaxCmdSN - conn->sess->ExpCmdSN + 1;
! 3232: SESS_MTX_UNLOCK(conn);
! 3233: QCmdSN += conn->queue_depth;
! 3234: if (SN32_LT(ExpStatSN + QCmdSN, conn->StatSN)) {
! 3235: ISTGT_ERRLOG("StatSN(%u/%u) QCmdSN(%u) error\n",
! 3236: ExpStatSN, conn->StatSN, QCmdSN);
! 3237: return -1;
! 3238: }
! 3239: }
! 3240:
! 3241: lu_cmd.pdu = pdu;
! 3242: SESS_MTX_LOCK(conn);
! 3243: lu_cmd.lu = conn->sess->lu;
! 3244: if (I_bit == 0) {
! 3245: conn->sess->ExpCmdSN++;
! 3246: if (conn->sess->req_mcs_cond > 0) {
! 3247: conn->sess->req_mcs_cond--;
! 3248: rc = pthread_cond_broadcast(&conn->sess->mcs_cond);
! 3249: if (rc != 0) {
! 3250: SESS_MTX_UNLOCK(conn);
! 3251: ISTGT_ERRLOG("cond_broadcast() failed\n");
! 3252: return -1;
! 3253: }
! 3254: }
! 3255: }
! 3256: SESS_MTX_UNLOCK(conn);
! 3257:
! 3258: if (R_bit != 0 && W_bit != 0) {
! 3259: ISTGT_ERRLOG("Bidirectional CDB is not supported\n");
! 3260: return -1;
! 3261: }
! 3262:
! 3263: lu_cmd.I_bit = I_bit;
! 3264: lu_cmd.F_bit = F_bit;
! 3265: lu_cmd.R_bit = R_bit;
! 3266: lu_cmd.W_bit = W_bit;
! 3267: lu_cmd.Attr_bit = Attr_bit;
! 3268: lu_cmd.lun = lun;
! 3269: lu_cmd.task_tag = task_tag;
! 3270: lu_cmd.transfer_len = transfer_len;
! 3271: lu_cmd.CmdSN = CmdSN;
! 3272: lu_cmd.cdb = cdb;
! 3273:
! 3274: lu_cmd.iobuf = conn->iobuf;
! 3275: lu_cmd.iobufsize = conn->iobufsize;
! 3276: lu_cmd.data = data;
! 3277: lu_cmd.data_len = 0;
! 3278: lu_cmd.alloc_len = alloc_len;
! 3279: lu_cmd.sense_data = conn->snsbuf;
! 3280: lu_cmd.sense_data_len = 0;
! 3281: lu_cmd.sense_alloc_len = conn->snsbufsize;
! 3282:
! 3283: /* need R2T? */
! 3284: if ((W_bit && F_bit) && (conn->max_r2t > 0)) {
! 3285: if (lu_cmd.pdu->data_segment_len < transfer_len) {
! 3286: rc = istgt_add_transfer_task(conn, &lu_cmd);
! 3287: if (rc < 0) {
! 3288: ISTGT_ERRLOG("add_transfer_task() failed\n");
! 3289: return -1;
! 3290: }
! 3291: }
! 3292: }
! 3293:
! 3294: /* execute SCSI command */
! 3295: rc = istgt_lu_execute(conn, &lu_cmd);
! 3296: if (rc < 0) {
! 3297: ISTGT_ERRLOG("lu_execute() failed\n");
! 3298: return -1;
! 3299: }
! 3300: switch (rc) {
! 3301: case ISTGT_LU_TASK_RESULT_QUEUE_OK:
! 3302: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Queue OK\n");
! 3303: return 0;
! 3304: case ISTGT_LU_TASK_RESULT_QUEUE_FULL:
! 3305: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Queue Full\n");
! 3306: ISTGT_WARNLOG("Queue Full\n");
! 3307: break;
! 3308: case ISTGT_LU_TASK_RESULT_IMMEDIATE:
! 3309: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Immediate\n");
! 3310: break;
! 3311: default:
! 3312: ISTGT_ERRLOG("lu_execute() unknown rc=%d\n", rc);
! 3313: return -1;
! 3314: }
! 3315:
! 3316: /* transfer data from logical unit */
! 3317: /* (direction is view of initiator side) */
! 3318: if (lu_cmd.R_bit
! 3319: && (lu_cmd.status == ISTGT_SCSI_STATUS_GOOD
! 3320: || lu_cmd.sense_data_len != 0)) {
! 3321: rc = istgt_iscsi_transfer_in(conn, &lu_cmd);
! 3322: if (rc < 0) {
! 3323: ISTGT_ERRLOG("iscsi_transfer_in() failed\n");
! 3324: return -1;
! 3325: }
! 3326: if (rc > 0) {
! 3327: /* sent status by last DATAIN PDU */
! 3328: return 0;
! 3329: }
! 3330: }
! 3331:
! 3332: o_bit = u_bit = O_bit = U_bit = 0;
! 3333: bidi_residual_len = residual_len = 0;
! 3334: data_len = lu_cmd.data_len;
! 3335: if (transfer_len != 0
! 3336: && lu_cmd.status == ISTGT_SCSI_STATUS_GOOD) {
! 3337: if (data_len < transfer_len) {
! 3338: /* underflow */
! 3339: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Underflow %u/%u\n",
! 3340: data_len, transfer_len);
! 3341: residual_len = transfer_len - data_len;
! 3342: U_bit = 1;
! 3343: } else if (data_len > transfer_len) {
! 3344: /* overflow */
! 3345: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Overflow %u/%u\n",
! 3346: data_len, transfer_len);
! 3347: residual_len = data_len - transfer_len;
! 3348: O_bit = 1;
! 3349: } else {
! 3350: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Transfer %u\n",
! 3351: transfer_len);
! 3352: }
! 3353: }
! 3354:
! 3355: /* response PDU */
! 3356: rsp = (uint8_t *) &rsp_pdu.bhs;
! 3357: rsp_pdu.data = lu_cmd.sense_data;
! 3358: memset(rsp, 0, ISCSI_BHS_LEN);
! 3359: rsp[0] = ISCSI_OP_SCSI_RSP;
! 3360: BDADD8(&rsp[1], 1, 7);
! 3361: BDADD8(&rsp[1], o_bit, 4);
! 3362: BDADD8(&rsp[1], u_bit, 3);
! 3363: BDADD8(&rsp[1], O_bit, 2);
! 3364: BDADD8(&rsp[1], U_bit, 1);
! 3365: rsp[2] = 0x00; // Command Completed at Target
! 3366: //rsp[2] = 0x01; // Target Failure
! 3367: rsp[3] = lu_cmd.status;
! 3368: rsp[4] = 0; // TotalAHSLength
! 3369: DSET24(&rsp[5], lu_cmd.sense_data_len); // DataSegmentLength
! 3370:
! 3371: DSET32(&rsp[16], task_tag);
! 3372: DSET32(&rsp[20], 0); // SNACK Tag
! 3373:
! 3374: DSET32(&rsp[24], conn->StatSN);
! 3375: conn->StatSN++;
! 3376: SESS_MTX_LOCK(conn);
! 3377: if (I_bit == 0) {
! 3378: conn->sess->MaxCmdSN++;
! 3379: }
! 3380: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 3381: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 3382: SESS_MTX_UNLOCK(conn);
! 3383:
! 3384: DSET32(&rsp[36], 0); // ExpDataSN
! 3385: DSET32(&rsp[40], bidi_residual_len);
! 3386: DSET32(&rsp[44], residual_len);
! 3387:
! 3388: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 3389: if (rc < 0) {
! 3390: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 3391: return -1;
! 3392: }
! 3393:
! 3394: return 0;
! 3395: }
! 3396:
! 3397: static int
! 3398: istgt_iscsi_task_transfer_out(CONN_Ptr conn, ISTGT_LU_TASK_Ptr lu_task)
! 3399: {
! 3400: ISTGT_LU_CMD_Ptr lu_cmd;
! 3401: uint32_t transfer_len;
! 3402: int rc;
! 3403:
! 3404: lu_cmd = &lu_task->lu_cmd;
! 3405: transfer_len = lu_cmd->transfer_len;
! 3406:
! 3407: rc = istgt_iscsi_transfer_out(conn, lu_cmd, lu_cmd->iobuf,
! 3408: lu_cmd->iobufsize, transfer_len);
! 3409: return rc;
! 3410: }
! 3411:
! 3412: static int
! 3413: istgt_iscsi_task_response(CONN_Ptr conn, ISTGT_LU_TASK_Ptr lu_task)
! 3414: {
! 3415: ISTGT_LU_CMD_Ptr lu_cmd;
! 3416: ISCSI_PDU rsp_pdu;
! 3417: uint8_t *rsp;
! 3418: uint32_t task_tag;
! 3419: uint32_t transfer_len;
! 3420: uint32_t CmdSN;
! 3421: int I_bit;
! 3422: int o_bit, u_bit, O_bit, U_bit;
! 3423: int bidi_residual_len;
! 3424: int residual_len;
! 3425: int data_len;
! 3426: int rc;
! 3427:
! 3428: lu_cmd = &lu_task->lu_cmd;
! 3429: transfer_len = lu_cmd->transfer_len;
! 3430: task_tag = lu_cmd->task_tag;
! 3431: I_bit = lu_cmd->I_bit;
! 3432: CmdSN = lu_cmd->CmdSN;
! 3433:
! 3434: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "SCSI response CmdSN=%u\n", CmdSN);
! 3435:
! 3436: /* transfer data from logical unit */
! 3437: /* (direction is view of initiator side) */
! 3438: if (lu_cmd->R_bit
! 3439: && (lu_cmd->status == ISTGT_SCSI_STATUS_GOOD
! 3440: || lu_cmd->sense_data_len != 0)) {
! 3441: if (lu_task->lock) {
! 3442: rc = istgt_iscsi_transfer_in_internal(conn, lu_cmd);
! 3443: } else {
! 3444: rc = istgt_iscsi_transfer_in(conn, lu_cmd);
! 3445: }
! 3446: if (rc < 0) {
! 3447: ISTGT_ERRLOG("iscsi_transfer_in() failed\n");
! 3448: return -1;
! 3449: }
! 3450: if (rc > 0) {
! 3451: /* sent status by last DATAIN PDU */
! 3452: return 0;
! 3453: }
! 3454: }
! 3455:
! 3456: o_bit = u_bit = O_bit = U_bit = 0;
! 3457: bidi_residual_len = residual_len = 0;
! 3458: data_len = lu_cmd->data_len;
! 3459: if (transfer_len != 0
! 3460: && lu_cmd->status == ISTGT_SCSI_STATUS_GOOD) {
! 3461: if (data_len < transfer_len) {
! 3462: /* underflow */
! 3463: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Underflow %u/%u\n",
! 3464: data_len, transfer_len);
! 3465: residual_len = transfer_len - data_len;
! 3466: U_bit = 1;
! 3467: } else if (data_len > transfer_len) {
! 3468: /* overflow */
! 3469: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Overflow %u/%u\n",
! 3470: data_len, transfer_len);
! 3471: residual_len = data_len - transfer_len;
! 3472: O_bit = 1;
! 3473: } else {
! 3474: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Transfer %u\n",
! 3475: transfer_len);
! 3476: }
! 3477: }
! 3478:
! 3479: /* response PDU */
! 3480: rsp = (uint8_t *) &rsp_pdu.bhs;
! 3481: rsp_pdu.data = lu_cmd->sense_data;
! 3482: memset(rsp, 0, ISCSI_BHS_LEN);
! 3483: rsp[0] = ISCSI_OP_SCSI_RSP;
! 3484: BDADD8(&rsp[1], 1, 7);
! 3485: BDADD8(&rsp[1], o_bit, 4);
! 3486: BDADD8(&rsp[1], u_bit, 3);
! 3487: BDADD8(&rsp[1], O_bit, 2);
! 3488: BDADD8(&rsp[1], U_bit, 1);
! 3489: rsp[2] = 0x00; // Command Completed at Target
! 3490: //rsp[2] = 0x01; // Target Failure
! 3491: rsp[3] = lu_cmd->status;
! 3492: rsp[4] = 0; // TotalAHSLength
! 3493: DSET24(&rsp[5], lu_cmd->sense_data_len); // DataSegmentLength
! 3494:
! 3495: DSET32(&rsp[16], task_tag);
! 3496: DSET32(&rsp[20], 0); // SNACK Tag
! 3497:
! 3498: DSET32(&rsp[24], conn->StatSN);
! 3499: conn->StatSN++;
! 3500: SESS_MTX_LOCK(conn);
! 3501: if (I_bit == 0) {
! 3502: conn->sess->MaxCmdSN++;
! 3503: }
! 3504: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 3505: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 3506: SESS_MTX_UNLOCK(conn);
! 3507:
! 3508: DSET32(&rsp[36], 0); // ExpDataSN
! 3509: DSET32(&rsp[40], bidi_residual_len);
! 3510: DSET32(&rsp[44], residual_len);
! 3511:
! 3512: if (lu_task->lock) {
! 3513: rc = istgt_iscsi_write_pdu_internal(conn, &rsp_pdu);
! 3514: } else {
! 3515: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 3516: }
! 3517: if (rc < 0) {
! 3518: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 3519: return -1;
! 3520: }
! 3521:
! 3522: return 0;
! 3523: }
! 3524:
! 3525: static int
! 3526: istgt_iscsi_op_task(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 3527: {
! 3528: ISCSI_PDU rsp_pdu;
! 3529: uint8_t *rsp;
! 3530: uint8_t *cp;
! 3531: uint64_t lun;
! 3532: uint32_t task_tag;
! 3533: uint32_t ref_task_tag;
! 3534: uint32_t CmdSN;
! 3535: uint32_t ExpStatSN;
! 3536: uint32_t ref_CmdSN;
! 3537: uint32_t ExpDataSN;
! 3538: int I_bit;
! 3539: int function;
! 3540: int response;
! 3541: int rc;
! 3542:
! 3543: if (!conn->full_feature) {
! 3544: ISTGT_ERRLOG("before Full Feature\n");
! 3545: return -1;
! 3546: }
! 3547:
! 3548: cp = (uint8_t *) &pdu->bhs;
! 3549: I_bit = BGET8(&cp[0], 6);
! 3550: function = BGET8W(&cp[1], 6, 7);
! 3551:
! 3552: lun = DGET64(&cp[8]);
! 3553: task_tag = DGET32(&cp[16]);
! 3554: ref_task_tag = DGET32(&cp[20]);
! 3555: CmdSN = DGET32(&cp[24]);
! 3556: ExpStatSN = DGET32(&cp[28]);
! 3557: ref_CmdSN = DGET32(&cp[32]);
! 3558: ExpDataSN = DGET32(&cp[36]);
! 3559:
! 3560: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3561: "I=%d, func=%d, ITT=%x, ref TT=%x, LUN=0x%16.16"PRIx64"\n",
! 3562: I_bit, function, task_tag, ref_task_tag, lun);
! 3563: SESS_MTX_LOCK(conn);
! 3564: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 3565: "CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 3566: CmdSN, ExpStatSN, conn->StatSN, conn->sess->ExpCmdSN,
! 3567: conn->sess->MaxCmdSN);
! 3568: if (CmdSN != conn->sess->ExpCmdSN) {
! 3569: ISTGT_WARNLOG("CmdSN(%u) might have dropped\n",
! 3570: conn->sess->ExpCmdSN);
! 3571: conn->sess->ExpCmdSN = CmdSN;
! 3572: }
! 3573: SESS_MTX_UNLOCK(conn);
! 3574: if (SN32_GT(ExpStatSN, conn->StatSN)) {
! 3575: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "StatSN(%u) advanced\n",
! 3576: ExpStatSN);
! 3577: conn->StatSN = ExpStatSN;
! 3578: }
! 3579: #if 0
! 3580: /* not need */
! 3581: if (ExpStatSN != conn->StatSN) {
! 3582: ISTGT_WARNLOG("StatSN(%u/%u) might have dropped\n",
! 3583: ExpStatSN, conn->StatSN);
! 3584: conn->StatSN = ExpStatSN;
! 3585: }
! 3586: #endif
! 3587:
! 3588: response = 0; // Function complete.
! 3589: switch (function) {
! 3590: case ISCSI_TASK_FUNC_ABORT_TASK:
! 3591: ISTGT_LOG("ABORT_TASK\n");
! 3592: SESS_MTX_LOCK(conn);
! 3593: rc = istgt_lu_clear_task_ITLQ(conn, conn->sess->lu, lun,
! 3594: ref_CmdSN);
! 3595: SESS_MTX_UNLOCK(conn);
! 3596: if (rc < 0) {
! 3597: ISTGT_ERRLOG("LU reset failed\n");
! 3598: }
! 3599: istgt_clear_transfer_task(conn, ref_CmdSN);
! 3600: break;
! 3601: case ISCSI_TASK_FUNC_ABORT_TASK_SET:
! 3602: ISTGT_LOG("ABORT_TASK_SET\n");
! 3603: SESS_MTX_LOCK(conn);
! 3604: rc = istgt_lu_clear_task_ITL(conn, conn->sess->lu, lun);
! 3605: SESS_MTX_UNLOCK(conn);
! 3606: if (rc < 0) {
! 3607: ISTGT_ERRLOG("LU reset failed\n");
! 3608: }
! 3609: istgt_clear_all_transfer_task(conn);
! 3610: break;
! 3611: case ISCSI_TASK_FUNC_CLEAR_ACA:
! 3612: ISTGT_LOG("CLEAR_ACA\n");
! 3613: break;
! 3614: case ISCSI_TASK_FUNC_CLEAR_TASK_SET:
! 3615: ISTGT_LOG("CLEAR_TASK_SET\n");
! 3616: SESS_MTX_LOCK(conn);
! 3617: rc = istgt_lu_clear_task_ITL(conn, conn->sess->lu, lun);
! 3618: SESS_MTX_UNLOCK(conn);
! 3619: if (rc < 0) {
! 3620: ISTGT_ERRLOG("LU reset failed\n");
! 3621: }
! 3622: istgt_clear_all_transfer_task(conn);
! 3623: break;
! 3624: case ISCSI_TASK_FUNC_LOGICAL_UNIT_RESET:
! 3625: ISTGT_LOG("LOGICAL_UNIT_RESET\n");
! 3626: istgt_iscsi_drop_all_conns(conn);
! 3627: SESS_MTX_LOCK(conn);
! 3628: rc = istgt_lu_reset(conn->sess->lu, lun);
! 3629: SESS_MTX_UNLOCK(conn);
! 3630: if (rc < 0) {
! 3631: ISTGT_ERRLOG("LU reset failed\n");
! 3632: }
! 3633: //conn->state = CONN_STATE_EXITING;
! 3634: break;
! 3635: case ISCSI_TASK_FUNC_TARGET_WARM_RESET:
! 3636: ISTGT_LOG("TARGET_WARM_RESET\n");
! 3637: istgt_iscsi_drop_all_conns(conn);
! 3638: SESS_MTX_LOCK(conn);
! 3639: rc = istgt_lu_reset(conn->sess->lu, lun);
! 3640: SESS_MTX_UNLOCK(conn);
! 3641: if (rc < 0) {
! 3642: ISTGT_ERRLOG("LU reset failed\n");
! 3643: }
! 3644: //conn->state = CONN_STATE_EXITING;
! 3645: break;
! 3646: case ISCSI_TASK_FUNC_TARGET_COLD_RESET:
! 3647: ISTGT_LOG("TARGET_COLD_RESET\n");
! 3648: istgt_iscsi_drop_all_conns(conn);
! 3649: SESS_MTX_LOCK(conn);
! 3650: rc = istgt_lu_reset(conn->sess->lu, lun);
! 3651: SESS_MTX_UNLOCK(conn);
! 3652: if (rc < 0) {
! 3653: ISTGT_ERRLOG("LU reset failed\n");
! 3654: }
! 3655: conn->state = CONN_STATE_EXITING;
! 3656: break;
! 3657: case ISCSI_TASK_FUNC_TASK_REASSIGN:
! 3658: ISTGT_LOG("TASK_REASSIGN\n");
! 3659: break;
! 3660: default:
! 3661: ISTGT_ERRLOG("unsupported function %d\n", function);
! 3662: response = 255; // Function rejected.
! 3663: break;
! 3664: }
! 3665:
! 3666: /* response PDU */
! 3667: rsp = (uint8_t *) &rsp_pdu.bhs;
! 3668: rsp_pdu.data = NULL;
! 3669: memset(rsp, 0, ISCSI_BHS_LEN);
! 3670: rsp[0] = ISCSI_OP_TASK_RSP;
! 3671: BDADD8(&rsp[1], 1, 7);
! 3672: rsp[2] = response;
! 3673: rsp[4] = 0; // TotalAHSLength
! 3674: DSET24(&rsp[5], 0); // DataSegmentLength
! 3675:
! 3676: DSET32(&rsp[16], task_tag);
! 3677:
! 3678: DSET32(&rsp[24], conn->StatSN);
! 3679: conn->StatSN++;
! 3680: SESS_MTX_LOCK(conn);
! 3681: if (I_bit == 0) {
! 3682: conn->sess->ExpCmdSN++;
! 3683: conn->sess->MaxCmdSN++;
! 3684: }
! 3685: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 3686: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 3687: SESS_MTX_UNLOCK(conn);
! 3688:
! 3689: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 3690: if (rc < 0) {
! 3691: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 3692: return -1;
! 3693: }
! 3694:
! 3695: return 0;
! 3696: }
! 3697:
! 3698: static int
! 3699: istgt_iscsi_op_nopout(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 3700: {
! 3701: ISCSI_PDU rsp_pdu;
! 3702: uint8_t *rsp;
! 3703: uint8_t *cp;
! 3704: uint8_t *data;
! 3705: uint64_t lun;
! 3706: uint32_t task_tag;
! 3707: uint32_t transfer_tag;
! 3708: uint32_t CmdSN;
! 3709: uint32_t ExpStatSN;
! 3710: int I_bit;
! 3711: int ping_len;
! 3712: int data_len;
! 3713: int alloc_len;
! 3714: int rc;
! 3715:
! 3716: if (!conn->full_feature) {
! 3717: ISTGT_ERRLOG("before Full Feature\n");
! 3718: return -1;
! 3719: }
! 3720:
! 3721: data_len = 0;
! 3722: alloc_len = conn->sendbufsize;
! 3723: data = (uint8_t *) conn->sendbuf;
! 3724: memset(data, 0, alloc_len);
! 3725:
! 3726: cp = (uint8_t *) &pdu->bhs;
! 3727: I_bit = BGET8(&cp[0], 6);
! 3728: ping_len = DGET24(&cp[5]);
! 3729:
! 3730: lun = DGET64(&cp[8]);
! 3731: task_tag = DGET32(&cp[16]);
! 3732: transfer_tag = DGET32(&cp[20]);
! 3733: CmdSN = DGET32(&cp[24]);
! 3734: ExpStatSN = DGET32(&cp[28]);
! 3735:
! 3736: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3737: "I=%d, ITT=%x, TTT=%x\n",
! 3738: I_bit, task_tag, transfer_tag);
! 3739: SESS_MTX_LOCK(conn);
! 3740: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 3741: "CmdSN=%u, ExpStatSN=%u, StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 3742: CmdSN, ExpStatSN, conn->StatSN, conn->sess->ExpCmdSN,
! 3743: conn->sess->MaxCmdSN);
! 3744: if (I_bit == 0) {
! 3745: if (SN32_LT(CmdSN, conn->sess->ExpCmdSN)
! 3746: || SN32_GT(CmdSN, conn->sess->MaxCmdSN)) {
! 3747: ISTGT_ERRLOG("CmdSN(%u) ignore (ExpCmdSN=%u, MaxCmdSN=%u)\n",
! 3748: CmdSN, conn->sess->ExpCmdSN,
! 3749: conn->sess->MaxCmdSN);
! 3750: SESS_MTX_UNLOCK(conn);
! 3751: return -1;
! 3752: }
! 3753: } else if (CmdSN != conn->sess->ExpCmdSN) {
! 3754: SESS_MTX_UNLOCK(conn);
! 3755: ISTGT_ERRLOG("CmdSN(%u) error\n", CmdSN);
! 3756: return -1;
! 3757: }
! 3758: SESS_MTX_UNLOCK(conn);
! 3759: if (SN32_GT(ExpStatSN, conn->StatSN)) {
! 3760: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "StatSN(%u) advanced\n",
! 3761: ExpStatSN);
! 3762: conn->StatSN = ExpStatSN;
! 3763: }
! 3764: {
! 3765: uint32_t QCmdSN;
! 3766: SESS_MTX_LOCK(conn);
! 3767: QCmdSN = conn->sess->MaxCmdSN - conn->sess->ExpCmdSN + 1;
! 3768: SESS_MTX_UNLOCK(conn);
! 3769: QCmdSN += conn->queue_depth;
! 3770: if (SN32_LT(ExpStatSN + QCmdSN, conn->StatSN)) {
! 3771: ISTGT_ERRLOG("StatSN(%u/%u) QCmdSN(%u) error\n",
! 3772: ExpStatSN, conn->StatSN, QCmdSN);
! 3773: return -1;
! 3774: }
! 3775: }
! 3776:
! 3777: if (task_tag == 0xffffffffU) {
! 3778: if (I_bit == 1) {
! 3779: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3780: "got NOPOUT ITT=0xffffffff\n");
! 3781: return 0;
! 3782: } else {
! 3783: ISTGT_ERRLOG("got NOPOUT ITT=0xffffffff, I=0\n");
! 3784: return -1;
! 3785: }
! 3786: }
! 3787:
! 3788: /* response of NOPOUT */
! 3789: if (ping_len != 0) {
! 3790: if (ping_len > alloc_len) {
! 3791: data_len = DMIN32(alloc_len,
! 3792: conn->MaxRecvDataSegmentLength);
! 3793: } else {
! 3794: data_len = DMIN32(ping_len,
! 3795: conn->MaxRecvDataSegmentLength);
! 3796: }
! 3797: /* ping data */
! 3798: memcpy(data, pdu->data, data_len);
! 3799: }
! 3800: transfer_tag = 0xffffffffU;
! 3801:
! 3802: /* response PDU */
! 3803: rsp = (uint8_t *) &rsp_pdu.bhs;
! 3804: rsp_pdu.data = data;
! 3805: memset(rsp, 0, ISCSI_BHS_LEN);
! 3806: rsp[0] = ISCSI_OP_NOPIN;
! 3807: BDADD8(&rsp[1], 1, 7);
! 3808: rsp[4] = 0; // TotalAHSLength
! 3809: DSET24(&rsp[5], data_len); // DataSegmentLength
! 3810:
! 3811: DSET64(&rsp[8], lun);
! 3812: DSET32(&rsp[16], task_tag);
! 3813: DSET32(&rsp[20], transfer_tag);
! 3814:
! 3815: DSET32(&rsp[24], conn->StatSN);
! 3816: conn->StatSN++;
! 3817: SESS_MTX_LOCK(conn);
! 3818: if (I_bit == 0) {
! 3819: conn->sess->ExpCmdSN++;
! 3820: conn->sess->MaxCmdSN++;
! 3821: }
! 3822: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 3823: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 3824: SESS_MTX_UNLOCK(conn);
! 3825:
! 3826: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 3827: if (rc < 0) {
! 3828: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 3829: return -1;
! 3830: }
! 3831:
! 3832: return 0;
! 3833: }
! 3834:
! 3835: static ISTGT_R2T_TASK_Ptr
! 3836: istgt_allocate_transfer_task(void)
! 3837: {
! 3838: ISTGT_R2T_TASK_Ptr r2t_task;
! 3839:
! 3840: r2t_task = xmalloc(sizeof *r2t_task);
! 3841: memset(r2t_task, 0, sizeof *r2t_task);
! 3842: r2t_task->conn = NULL;
! 3843: r2t_task->lu = NULL;
! 3844: r2t_task->iobuf = NULL;
! 3845: return r2t_task;
! 3846: }
! 3847:
! 3848: static void
! 3849: istgt_free_transfer_task(ISTGT_R2T_TASK_Ptr r2t_task)
! 3850: {
! 3851: if (r2t_task == NULL)
! 3852: return;
! 3853: xfree(r2t_task->iobuf);
! 3854: xfree(r2t_task);
! 3855: }
! 3856:
! 3857: static ISTGT_R2T_TASK_Ptr
! 3858: istgt_get_transfer_task(CONN_Ptr conn, uint32_t transfer_tag)
! 3859: {
! 3860: ISTGT_R2T_TASK_Ptr r2t_task;
! 3861: int i;
! 3862:
! 3863: MTX_LOCK(&conn->r2t_mutex);
! 3864: if (conn->pending_r2t == 0) {
! 3865: MTX_UNLOCK(&conn->r2t_mutex);
! 3866: return NULL;
! 3867: }
! 3868: for (i = 0; i < conn->pending_r2t; i++) {
! 3869: r2t_task = conn->r2t_tasks[i];
! 3870: #if 0
! 3871: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3872: "CmdSN=%d, TransferTag=%x/%x\n",
! 3873: r2t_task->CmdSN, r2t_task->transfer_tag, transfer_tag);
! 3874: #endif
! 3875: if (r2t_task->transfer_tag == transfer_tag) {
! 3876: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3877: "Match index=%d, CmdSN=%d, TransferTag=%x\n",
! 3878: i, r2t_task->CmdSN, r2t_task->transfer_tag);
! 3879: MTX_UNLOCK(&conn->r2t_mutex);
! 3880: return r2t_task;
! 3881: }
! 3882: }
! 3883: MTX_UNLOCK(&conn->r2t_mutex);
! 3884: return NULL;
! 3885: }
! 3886:
! 3887: static int
! 3888: istgt_add_transfer_task(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd)
! 3889: {
! 3890: ISTGT_R2T_TASK_Ptr r2t_task;
! 3891: uint32_t transfer_len;
! 3892: uint32_t transfer_tag;
! 3893: int first_burst_len;
! 3894: int max_burst_len;
! 3895: int data_len;
! 3896: int offset = 0;
! 3897: int len;
! 3898: int idx;
! 3899: int rc;
! 3900:
! 3901: MTX_LOCK(&conn->r2t_mutex);
! 3902: if (conn->pending_r2t >= conn->max_r2t) {
! 3903: // no slot available, skip now...
! 3904: //ISTGT_WARNLOG("No R2T space available (%d/%d)\n",
! 3905: // conn->pending_r2t, conn->max_r2t);
! 3906: MTX_UNLOCK(&conn->r2t_mutex);
! 3907: return 0;
! 3908: }
! 3909: MTX_UNLOCK(&conn->r2t_mutex);
! 3910:
! 3911: transfer_len = lu_cmd->transfer_len;
! 3912: transfer_tag = lu_cmd->task_tag;
! 3913: data_len = lu_cmd->pdu->data_segment_len;
! 3914: first_burst_len = conn->FirstBurstLength;
! 3915: max_burst_len = conn->MaxBurstLength;
! 3916: offset += data_len;
! 3917: if (offset >= first_burst_len) {
! 3918: len = DMIN32(max_burst_len, (transfer_len - offset));
! 3919:
! 3920: r2t_task = istgt_allocate_transfer_task();
! 3921: r2t_task->conn = conn;
! 3922: r2t_task->lu = lu_cmd->lu;
! 3923: r2t_task->lun = lu_cmd->lun;
! 3924: r2t_task->CmdSN = lu_cmd->CmdSN;
! 3925: r2t_task->task_tag = lu_cmd->task_tag;
! 3926: r2t_task->transfer_len = transfer_len;
! 3927: r2t_task->transfer_tag = transfer_tag;
! 3928:
! 3929: r2t_task->iobufsize = lu_cmd->transfer_len + 65536;
! 3930: r2t_task->iobuf = xmalloc(r2t_task->iobufsize);
! 3931: memcpy(r2t_task->iobuf, lu_cmd->pdu->data, data_len);
! 3932: r2t_task->offset = offset;
! 3933: r2t_task->R2TSN = 0;
! 3934: r2t_task->DataSN = 0;
! 3935: r2t_task->F_bit = lu_cmd->F_bit;
! 3936:
! 3937: MTX_LOCK(&conn->r2t_mutex);
! 3938: idx = conn->pending_r2t++;
! 3939: conn->r2t_tasks[idx] = r2t_task;
! 3940: MTX_UNLOCK(&conn->r2t_mutex);
! 3941:
! 3942: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3943: "Send R2T(Offset=%d, Tag=%x)\n",
! 3944: r2t_task->offset, r2t_task->transfer_tag);
! 3945: rc = istgt_iscsi_send_r2t(conn, lu_cmd,
! 3946: r2t_task->offset, len, r2t_task->transfer_tag,
! 3947: &r2t_task->R2TSN);
! 3948: if (rc < 0) {
! 3949: ISTGT_ERRLOG("iscsi_send_r2t() failed\n");
! 3950: return -1;
! 3951: }
! 3952: }
! 3953: return 0;
! 3954: }
! 3955:
! 3956: static void
! 3957: istgt_del_transfer_task(CONN_Ptr conn, ISTGT_R2T_TASK_Ptr r2t_task)
! 3958: {
! 3959: int found = 0;
! 3960: int i;
! 3961:
! 3962: if (r2t_task == NULL)
! 3963: return;
! 3964:
! 3965: MTX_LOCK(&conn->r2t_mutex);
! 3966: if (conn->pending_r2t == 0) {
! 3967: MTX_UNLOCK(&conn->r2t_mutex);
! 3968: return;
! 3969: }
! 3970: for (i = 0; i < conn->pending_r2t; i++) {
! 3971: if (conn->r2t_tasks[i] == r2t_task) {
! 3972: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 3973: "Remove R2T task conn id=%d, index=%d\n",
! 3974: conn->id, i);
! 3975: found = 1;
! 3976: break;
! 3977: }
! 3978: }
! 3979: if (found) {
! 3980: for ( ; i < conn->pending_r2t; i++) {
! 3981: conn->r2t_tasks[i] = conn->r2t_tasks[i + 1];
! 3982: }
! 3983: conn->pending_r2t--;
! 3984: conn->r2t_tasks[conn->pending_r2t] = NULL;
! 3985: }
! 3986: MTX_UNLOCK(&conn->r2t_mutex);
! 3987: }
! 3988:
! 3989: static void
! 3990: istgt_clear_transfer_task(CONN_Ptr conn, uint32_t CmdSN)
! 3991: {
! 3992: int found = 0;
! 3993: int i;
! 3994:
! 3995: MTX_LOCK(&conn->r2t_mutex);
! 3996: if (conn->pending_r2t == 0) {
! 3997: MTX_UNLOCK(&conn->r2t_mutex);
! 3998: return;
! 3999: }
! 4000: for (i = 0; i < conn->pending_r2t; i++) {
! 4001: if (conn->r2t_tasks[i]->CmdSN == CmdSN) {
! 4002: istgt_free_transfer_task(conn->r2t_tasks[i]);
! 4003: conn->r2t_tasks[i] = NULL;
! 4004: found = 1;
! 4005: break;
! 4006: }
! 4007: }
! 4008: if (found) {
! 4009: for ( ; i < conn->pending_r2t; i++) {
! 4010: conn->r2t_tasks[i] = conn->r2t_tasks[i + 1];
! 4011: }
! 4012: conn->pending_r2t--;
! 4013: conn->r2t_tasks[conn->pending_r2t] = NULL;
! 4014: }
! 4015: MTX_UNLOCK(&conn->r2t_mutex);
! 4016: }
! 4017:
! 4018: static void
! 4019: istgt_clear_all_transfer_task(CONN_Ptr conn)
! 4020: {
! 4021: int i;
! 4022:
! 4023: MTX_LOCK(&conn->r2t_mutex);
! 4024: if (conn->pending_r2t == 0) {
! 4025: MTX_UNLOCK(&conn->r2t_mutex);
! 4026: return;
! 4027: }
! 4028: for (i = 0; i < conn->pending_r2t; i++) {
! 4029: istgt_free_transfer_task(conn->r2t_tasks[i]);
! 4030: conn->r2t_tasks[i] = NULL;
! 4031: }
! 4032: conn->pending_r2t = 0;
! 4033: MTX_UNLOCK(&conn->r2t_mutex);
! 4034: }
! 4035:
! 4036: static int
! 4037: istgt_iscsi_op_data(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 4038: {
! 4039: ISTGT_R2T_TASK_Ptr r2t_task;
! 4040: uint8_t *cp;
! 4041: uint8_t *data;
! 4042: uint64_t lun;
! 4043: uint64_t current_lun;
! 4044: uint32_t current_task_tag;
! 4045: uint32_t current_transfer_tag;
! 4046: uint32_t ExpStatSN;
! 4047: uint32_t task_tag;
! 4048: uint32_t transfer_tag;
! 4049: uint32_t ExpDataSN;
! 4050: uint32_t DataSN;
! 4051: uint32_t buffer_offset;
! 4052: int F_bit;
! 4053: int data_len;
! 4054: int alloc_len;
! 4055: int offset;
! 4056: int rc;
! 4057:
! 4058: if (!conn->full_feature) {
! 4059: ISTGT_ERRLOG("before Full Feature\n");
! 4060: return -1;
! 4061: }
! 4062: MTX_LOCK(&conn->r2t_mutex);
! 4063: if (conn->pending_r2t == 0) {
! 4064: ISTGT_ERRLOG("No R2T task\n");
! 4065: MTX_UNLOCK(&conn->r2t_mutex);
! 4066: reject_return:
! 4067: rc = istgt_iscsi_reject(conn, pdu, 0x09);
! 4068: if (rc < 0) {
! 4069: ISTGT_ERRLOG("iscsi_reject() failed\n");
! 4070: return -1;
! 4071: }
! 4072: return 0;
! 4073: }
! 4074: MTX_UNLOCK(&conn->r2t_mutex);
! 4075:
! 4076: cp = (uint8_t *) &pdu->bhs;
! 4077: F_bit = BGET8(&cp[1], 7);
! 4078: data_len = DGET24(&cp[5]);
! 4079:
! 4080: lun = DGET64(&cp[8]);
! 4081: task_tag = DGET32(&cp[16]);
! 4082: transfer_tag = DGET32(&cp[20]);
! 4083: ExpStatSN = DGET32(&cp[28]);
! 4084: DataSN = DGET32(&cp[36]);
! 4085: buffer_offset = DGET32(&cp[40]);
! 4086:
! 4087: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4088: "pending R2T = %d\n", conn->pending_r2t);
! 4089:
! 4090: r2t_task = istgt_get_transfer_task(conn, transfer_tag);
! 4091: if (r2t_task == NULL) {
! 4092: ISTGT_ERRLOG("Not found R2T task for transfer_tag=%x\n",
! 4093: transfer_tag);
! 4094: goto reject_return;
! 4095: }
! 4096:
! 4097: current_lun = r2t_task->lun;
! 4098: current_task_tag = r2t_task->task_tag;
! 4099: current_transfer_tag = r2t_task->transfer_tag;
! 4100: offset = r2t_task->offset;
! 4101: data = r2t_task->iobuf;
! 4102: alloc_len = r2t_task->iobufsize;
! 4103: ExpDataSN = r2t_task->DataSN;
! 4104:
! 4105: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 4106: "StatSN=%u, ExpStatSN=%u, DataSN=%u, Offset=%u, Data=%d\n",
! 4107: conn->StatSN, ExpStatSN, DataSN, buffer_offset, data_len);
! 4108: if (DataSN != ExpDataSN) {
! 4109: ISTGT_ERRLOG("DataSN(%u) error\n", DataSN);
! 4110: return -1;
! 4111: }
! 4112: if (task_tag != current_task_tag) {
! 4113: ISTGT_ERRLOG("task_tag(%x/%x) error\n",
! 4114: task_tag, current_task_tag);
! 4115: return -1;
! 4116: }
! 4117: if (transfer_tag != current_transfer_tag) {
! 4118: ISTGT_ERRLOG("transfer_tag(%x/%x) error\n",
! 4119: transfer_tag, current_transfer_tag);
! 4120: return -1;
! 4121: }
! 4122: if (buffer_offset != offset) {
! 4123: ISTGT_ERRLOG("offset(%u) error\n", buffer_offset);
! 4124: return -1;
! 4125: }
! 4126: if (buffer_offset + data_len > alloc_len) {
! 4127: ISTGT_ERRLOG("offset error\n");
! 4128: return -1;
! 4129: }
! 4130:
! 4131: memcpy(data + buffer_offset, pdu->data, data_len);
! 4132: offset += data_len;
! 4133: ExpDataSN++;
! 4134:
! 4135: r2t_task->offset = offset;
! 4136: r2t_task->DataSN = ExpDataSN;
! 4137: r2t_task->F_bit = F_bit;
! 4138: return 0;
! 4139: }
! 4140:
! 4141: static int
! 4142: istgt_iscsi_send_r2t(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, int offset, int len, uint32_t transfer_tag, uint32_t *R2TSN)
! 4143: {
! 4144: ISCSI_PDU rsp_pdu;
! 4145: uint8_t *rsp;
! 4146: int rc;
! 4147:
! 4148: /* R2T PDU */
! 4149: rsp = (uint8_t *) &rsp_pdu.bhs;
! 4150: rsp_pdu.data = NULL;
! 4151: memset(rsp, 0, ISCSI_BHS_LEN);
! 4152: rsp[0] = ISCSI_OP_R2T;
! 4153: BDADD8(&rsp[1], 1, 7);
! 4154: rsp[4] = 0; // TotalAHSLength
! 4155: DSET24(&rsp[5], 0); // DataSegmentLength
! 4156:
! 4157: DSET64(&rsp[8], lu_cmd->lun);
! 4158: DSET32(&rsp[16], lu_cmd->task_tag);
! 4159: DSET32(&rsp[20], transfer_tag);
! 4160:
! 4161: DSET32(&rsp[24], conn->StatSN);
! 4162: SESS_MTX_LOCK(conn);
! 4163: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 4164: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 4165: SESS_MTX_UNLOCK(conn);
! 4166:
! 4167: DSET32(&rsp[36], *R2TSN);
! 4168: *R2TSN += 1;
! 4169: DSET32(&rsp[40], (uint32_t) offset);
! 4170: DSET32(&rsp[44], (uint32_t) len);
! 4171:
! 4172: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 4173: if (rc < 0) {
! 4174: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 4175: return -1;
! 4176: }
! 4177:
! 4178: return 0;
! 4179: }
! 4180:
! 4181: int
! 4182: istgt_iscsi_transfer_out(CONN_Ptr conn, ISTGT_LU_CMD_Ptr lu_cmd, uint8_t *data, int alloc_len, int transfer_len)
! 4183: {
! 4184: ISTGT_R2T_TASK_Ptr r2t_task;
! 4185: ISCSI_PDU data_pdu;
! 4186: uint8_t *cp;
! 4187: uint64_t current_lun;
! 4188: uint64_t lun;
! 4189: uint32_t current_task_tag;
! 4190: uint32_t current_transfer_tag;
! 4191: uint32_t ExpDataSN;
! 4192: uint32_t task_tag;
! 4193: uint32_t transfer_tag;
! 4194: uint32_t ExpStatSN;
! 4195: uint32_t DataSN;
! 4196: uint32_t buffer_offset;
! 4197: uint32_t R2TSN;
! 4198: int immediate, opcode;
! 4199: int F_bit;
! 4200: int data_len;
! 4201: int segment_len;
! 4202: int first_burst_len;
! 4203: int max_burst_len;
! 4204: int offset;
! 4205: int len;
! 4206: int r2t_flag;
! 4207: int r2t_offset;
! 4208: int r2t_sent;
! 4209: int rc;
! 4210:
! 4211: current_lun = lu_cmd->lun;
! 4212: current_task_tag = lu_cmd->task_tag;
! 4213: current_transfer_tag = lu_cmd->task_tag;
! 4214: ExpDataSN = 0;
! 4215: segment_len = conn->MaxRecvDataSegmentLength;
! 4216: first_burst_len = conn->FirstBurstLength;
! 4217: max_burst_len = conn->MaxBurstLength;
! 4218: offset = 0;
! 4219: r2t_flag = 0;
! 4220: r2t_offset = 0;
! 4221: r2t_sent = 0;
! 4222: R2TSN = 0;
! 4223:
! 4224: cp = (uint8_t *) &lu_cmd->pdu->bhs;
! 4225: data_len = DGET24(&cp[5]);
! 4226:
! 4227: if (transfer_len > alloc_len) {
! 4228: ISTGT_ERRLOG("transfer_len > alloc_len\n");
! 4229: return -1;
! 4230: }
! 4231:
! 4232: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4233: "Transfer=%d, First=%d, Max=%d, Segment=%d\n",
! 4234: transfer_len, data_len, max_burst_len, segment_len);
! 4235:
! 4236: r2t_task = istgt_get_transfer_task(conn, current_transfer_tag);
! 4237: if (r2t_task != NULL) {
! 4238: current_lun = r2t_task->lun;
! 4239: current_task_tag = r2t_task->task_tag;
! 4240: current_transfer_tag = r2t_task->transfer_tag;
! 4241: offset = r2t_task->offset;
! 4242: R2TSN = r2t_task->R2TSN;
! 4243: ExpDataSN = r2t_task->DataSN;
! 4244: F_bit = r2t_task->F_bit;
! 4245: r2t_flag = 1;
! 4246: data_len = 0;
! 4247:
! 4248: memcpy(data, r2t_task->iobuf, offset);
! 4249: istgt_del_transfer_task(conn, r2t_task);
! 4250: istgt_free_transfer_task(r2t_task);
! 4251:
! 4252: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4253: "Using R2T(%d) offset=%d, DataSN=%d\n",
! 4254: conn->pending_r2t, offset, ExpDataSN);
! 4255:
! 4256: rc = istgt_queue_count(&conn->pending_pdus);
! 4257: if (rc > 0) {
! 4258: if (g_trace_flag) {
! 4259: ISTGT_WARNLOG("pending_pdus > 0\n");
! 4260: }
! 4261: }
! 4262: if (offset < transfer_len) {
! 4263: if (offset >= (first_burst_len + max_burst_len)) {
! 4264: /* need more data */
! 4265: r2t_flag = 0;
! 4266: }
! 4267: len = DMIN32(max_burst_len,
! 4268: (transfer_len - offset));
! 4269: memset(&data_pdu.bhs, 0, ISCSI_BHS_LEN);
! 4270: data_pdu.ahs = NULL;
! 4271: data_pdu.data = NULL;
! 4272: data_pdu.copy_pdu = 0;
! 4273: goto r2t_retry;
! 4274: } else if (offset == transfer_len) {
! 4275: if (F_bit == 0) {
! 4276: ISTGT_ERRLOG("F_bit not set on the last PDU\n");
! 4277: return -1;
! 4278: }
! 4279: }
! 4280: goto r2t_return;
! 4281: }
! 4282:
! 4283: if (data_len != 0) {
! 4284: if (data_len > first_burst_len) {
! 4285: ISTGT_ERRLOG("data_len > first_burst_len\n");
! 4286: return -1;
! 4287: }
! 4288: if (offset + data_len > alloc_len) {
! 4289: ISTGT_ERRLOG("offset + data_len > alloc_len\n");
! 4290: return -1;
! 4291: }
! 4292: memcpy(data + offset, lu_cmd->pdu->data, data_len);
! 4293: offset += data_len;
! 4294: r2t_offset = offset;
! 4295: }
! 4296:
! 4297: if (offset < transfer_len) {
! 4298: len = DMIN32(first_burst_len, (transfer_len - offset));
! 4299: memset(&data_pdu.bhs, 0, ISCSI_BHS_LEN);
! 4300: data_pdu.ahs = NULL;
! 4301: data_pdu.data = NULL;
! 4302: data_pdu.copy_pdu = 0;
! 4303: do {
! 4304: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4305: "Transfer=%d, Offset=%d, Len=%d\n",
! 4306: transfer_len, offset, len);
! 4307: /* send R2T if required */
! 4308: if (r2t_flag == 0
! 4309: && (conn->sess->initial_r2t || offset >= first_burst_len)) {
! 4310: len = DMIN32(max_burst_len,
! 4311: (transfer_len - offset));
! 4312: rc = istgt_iscsi_send_r2t(conn, lu_cmd,
! 4313: offset, len, current_transfer_tag, &R2TSN);
! 4314: if (rc < 0) {
! 4315: ISTGT_ERRLOG("iscsi_send_r2t() failed\n");
! 4316: error_return:
! 4317: if (data_pdu.copy_pdu == 0) {
! 4318: xfree(data_pdu.ahs);
! 4319: data_pdu.ahs = NULL;
! 4320: if (data_pdu.data
! 4321: != data_pdu.shortdata) {
! 4322: xfree(data_pdu.data);
! 4323: }
! 4324: data_pdu.data = NULL;
! 4325: }
! 4326: return -1;
! 4327: }
! 4328: r2t_flag = 1;
! 4329: r2t_offset = offset;
! 4330: r2t_sent = 1;
! 4331: ExpDataSN = 0;
! 4332: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4333: "R2T, Transfer=%d, Offset=%d, Len=%d\n",
! 4334: transfer_len, offset, len);
! 4335: } else {
! 4336: r2t_sent = 0;
! 4337: }
! 4338:
! 4339: /* transfer by segment_len */
! 4340: rc = istgt_iscsi_read_pdu(conn, &data_pdu);
! 4341: if (rc < 0) {
! 4342: //ISTGT_ERRLOG("iscsi_read_pdu() failed\n");
! 4343: ISTGT_ERRLOG("iscsi_read_pdu() failed, r2t_sent=%d\n",
! 4344: r2t_sent);
! 4345: goto error_return;
! 4346: }
! 4347: immediate = BGET8W(&data_pdu.bhs.opcode, 6, 1);
! 4348: opcode = BGET8W(&data_pdu.bhs.opcode, 5, 6);
! 4349:
! 4350: cp = (uint8_t *) &data_pdu.bhs;
! 4351: F_bit = BGET8(&cp[1], 7);
! 4352: data_len = DGET24(&cp[5]);
! 4353:
! 4354: lun = DGET64(&cp[8]);
! 4355: task_tag = DGET32(&cp[16]);
! 4356: transfer_tag = DGET32(&cp[20]);
! 4357: ExpStatSN = DGET32(&cp[28]);
! 4358: DataSN = DGET32(&cp[36]);
! 4359: buffer_offset = DGET32(&cp[40]);
! 4360:
! 4361: /* current tag DATA? */
! 4362: if (opcode == ISCSI_OP_SCSI_DATAOUT) {
! 4363: if (task_tag != current_task_tag) {
! 4364: not_current_tag:
! 4365: //ISTGT_LOG("not task_tag received\n");
! 4366: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4367: "not task_tag received\n");
! 4368: rc = istgt_iscsi_op_data(conn,
! 4369: &data_pdu);
! 4370: if (rc < 0) {
! 4371: ISTGT_ERRLOG("iscsi_op_data() failed\n");
! 4372: goto error_return;
! 4373: }
! 4374: if (data_pdu.data != data_pdu.shortdata) {
! 4375: xfree(data_pdu.data);
! 4376: }
! 4377: data_pdu.ahs = NULL;
! 4378: data_pdu.data = NULL;
! 4379: data_pdu.copy_pdu = 0;
! 4380: continue;
! 4381: }
! 4382: if (transfer_tag != current_transfer_tag) {
! 4383: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4384: "not transfer_tag received\n");
! 4385: goto not_current_tag;
! 4386: }
! 4387: }
! 4388:
! 4389: if (opcode != ISCSI_OP_SCSI_DATAOUT) {
! 4390: ISCSI_PDU_Ptr save_pdu;
! 4391:
! 4392: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4393: "non DATAOUT PDU received and pending"
! 4394: " (OP=0x%x)\n",
! 4395: opcode);
! 4396:
! 4397: rc = istgt_queue_count(&conn->pending_pdus);
! 4398: if (rc > conn->max_pending) {
! 4399: ISTGT_ERRLOG("pending queue(%d) is full\n",
! 4400: conn->max_pending);
! 4401: goto error_return;
! 4402: }
! 4403: save_pdu = xmalloc(sizeof *save_pdu);
! 4404: memset(save_pdu, 0, sizeof *save_pdu);
! 4405: rc = istgt_iscsi_copy_pdu(save_pdu, &data_pdu);
! 4406: if (rc < 0) {
! 4407: ISTGT_ERRLOG("iscsi_copy_pdu() failed\n");
! 4408: xfree(save_pdu);
! 4409: save_pdu = NULL;
! 4410: goto error_return;
! 4411: }
! 4412: rc = istgt_queue_enqueue(&conn->pending_pdus,
! 4413: save_pdu);
! 4414: if (rc < 0) {
! 4415: ISTGT_ERRLOG("queue_enqueue() failed\n");
! 4416: xfree(save_pdu->ahs);
! 4417: save_pdu->ahs = NULL;
! 4418: if (save_pdu->data
! 4419: != save_pdu->shortdata) {
! 4420: xfree(save_pdu->data);
! 4421: }
! 4422: save_pdu->data = NULL;
! 4423: xfree(save_pdu);
! 4424: save_pdu = NULL;
! 4425: goto error_return;
! 4426: }
! 4427: data_pdu.ahs = NULL;
! 4428: data_pdu.data = NULL;
! 4429: data_pdu.copy_pdu = 0;
! 4430: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4431: "non DATAOUT PDU pending\n");
! 4432: continue;
! 4433: }
! 4434:
! 4435: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 4436: "StatSN=%u, "
! 4437: "ExpStatSN=%u, DataSN=%u, Offset=%u, Data=%d\n",
! 4438: conn->StatSN,
! 4439: ExpStatSN, DataSN, buffer_offset, data_len);
! 4440: if (DataSN != ExpDataSN) {
! 4441: ISTGT_ERRLOG("DataSN(%u) error\n", DataSN);
! 4442: goto error_return;
! 4443: }
! 4444: #if 0
! 4445: /* not check in DATAOUT */
! 4446: if (ExpStatSN != conn->StatSN) {
! 4447: ISTGT_ERRLOG("StatSN(%u) error\n",
! 4448: conn->StatSN);
! 4449: goto error_return;
! 4450: }
! 4451: #endif
! 4452:
! 4453: #if 0
! 4454: /* not check in DATAOUT */
! 4455: if (lun != current_lun) {
! 4456: #if 0
! 4457: ISTGT_ERRLOG("lun(0x%16.16"PRIx64") error\n",
! 4458: lun);
! 4459: goto error_return;
! 4460: #else
! 4461: ISTGT_WARNLOG("lun(0x%16.16"PRIx64")\n", lun);
! 4462: #endif
! 4463: }
! 4464: #endif
! 4465: if (task_tag != current_task_tag) {
! 4466: ISTGT_ERRLOG("task_tag(%x/%x) error\n",
! 4467: task_tag, current_task_tag);
! 4468: goto error_return;
! 4469: }
! 4470: if (transfer_tag != current_transfer_tag) {
! 4471: ISTGT_ERRLOG("transfer_tag(%x/%x) error\n",
! 4472: transfer_tag, current_transfer_tag);
! 4473: goto error_return;
! 4474: }
! 4475: if (buffer_offset != offset) {
! 4476: ISTGT_ERRLOG("offset(%u) error\n",
! 4477: buffer_offset);
! 4478: goto error_return;
! 4479: }
! 4480: if (buffer_offset + data_len > alloc_len) {
! 4481: ISTGT_ERRLOG("offset error\n");
! 4482: goto error_return;
! 4483: }
! 4484:
! 4485: memcpy(data + buffer_offset, data_pdu.data, data_len);
! 4486: offset += data_len;
! 4487: len -= data_len;
! 4488: ExpDataSN++;
! 4489:
! 4490: if (r2t_flag == 0 && (offset > first_burst_len)) {
! 4491: ISTGT_ERRLOG("data_len(%d) > first_burst_length(%d)",
! 4492: offset, first_burst_len);
! 4493: goto error_return;
! 4494: }
! 4495: if (F_bit != 0 && len != 0) {
! 4496: if (offset < transfer_len) {
! 4497: r2t_flag = 0;
! 4498: goto r2t_retry;
! 4499: }
! 4500: ISTGT_ERRLOG("Expecting more data %d\n", len);
! 4501: goto error_return;
! 4502: }
! 4503: if (F_bit == 0 && len == 0) {
! 4504: ISTGT_ERRLOG("F_bit not set on the last PDU\n");
! 4505: goto error_return;
! 4506: }
! 4507: if (len == 0) {
! 4508: r2t_flag = 0;
! 4509: }
! 4510: r2t_retry:
! 4511: if (data_pdu.copy_pdu == 0) {
! 4512: xfree(data_pdu.ahs);
! 4513: data_pdu.ahs = NULL;
! 4514: if (data_pdu.data != data_pdu.shortdata) {
! 4515: xfree(data_pdu.data);
! 4516: }
! 4517: data_pdu.data = NULL;
! 4518: }
! 4519: } while (offset < transfer_len);
! 4520:
! 4521: cp = (uint8_t *) &data_pdu.bhs;
! 4522: F_bit = BGET8(&cp[1], 7);
! 4523: if (F_bit == 0) {
! 4524: ISTGT_ERRLOG("F_bit not set on the last PDU\n");
! 4525: return -1;
! 4526: }
! 4527: } else {
! 4528: cp = (uint8_t *) &lu_cmd->pdu->bhs;
! 4529: F_bit = BGET8(&cp[1], 7);
! 4530: if (F_bit == 0) {
! 4531: ISTGT_ERRLOG("F_bit not set on the last PDU\n");
! 4532: return -1;
! 4533: }
! 4534: }
! 4535:
! 4536: r2t_return:
! 4537: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "Transfered=%d, Offset=%d\n",
! 4538: transfer_len, offset);
! 4539:
! 4540: return 0;
! 4541: }
! 4542:
! 4543: static int
! 4544: istgt_iscsi_send_nopin(CONN_Ptr conn)
! 4545: {
! 4546: ISCSI_PDU rsp_pdu;
! 4547: uint8_t *rsp;
! 4548: uint64_t lun;
! 4549: uint32_t task_tag;
! 4550: uint32_t transfer_tag;
! 4551: int rc;
! 4552:
! 4553: if (conn->sess == NULL) {
! 4554: return 0;
! 4555: }
! 4556: if (!conn->full_feature) {
! 4557: ISTGT_ERRLOG("before Full Feature\n");
! 4558: return -1;
! 4559: }
! 4560:
! 4561: SESS_MTX_LOCK(conn);
! 4562: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4563: "send NOPIN isid=%"PRIx64", tsih=%u, cid=%u\n",
! 4564: conn->sess->isid, conn->sess->tsih, conn->cid);
! 4565: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 4566: "StatSN=%u, ExpCmdSN=%u, MaxCmdSN=%u\n",
! 4567: conn->StatSN, conn->sess->ExpCmdSN,
! 4568: conn->sess->MaxCmdSN);
! 4569: SESS_MTX_UNLOCK(conn);
! 4570:
! 4571: /* without wanting NOPOUT */
! 4572: lun = 0;
! 4573: task_tag = 0xffffffffU;
! 4574: transfer_tag = 0xffffffffU;
! 4575:
! 4576: /* response PDU */
! 4577: rsp = (uint8_t *) &rsp_pdu.bhs;
! 4578: rsp_pdu.data = NULL;
! 4579: memset(rsp, 0, ISCSI_BHS_LEN);
! 4580: rsp[0] = ISCSI_OP_NOPIN;
! 4581: BDADD8(&rsp[1], 1, 7);
! 4582: rsp[4] = 0; // TotalAHSLength
! 4583: DSET24(&rsp[5], 0); // DataSegmentLength
! 4584:
! 4585: DSET64(&rsp[8], lun);
! 4586: DSET32(&rsp[16], task_tag);
! 4587: DSET32(&rsp[20], transfer_tag);
! 4588:
! 4589: DSET32(&rsp[24], conn->StatSN);
! 4590: SESS_MTX_LOCK(conn);
! 4591: DSET32(&rsp[28], conn->sess->ExpCmdSN);
! 4592: DSET32(&rsp[32], conn->sess->MaxCmdSN);
! 4593: SESS_MTX_UNLOCK(conn);
! 4594:
! 4595: rc = istgt_iscsi_write_pdu(conn, &rsp_pdu);
! 4596: if (rc < 0) {
! 4597: ISTGT_ERRLOG("iscsi_write_pdu() failed\n");
! 4598: return -1;
! 4599: }
! 4600:
! 4601: return 0;
! 4602: }
! 4603:
! 4604: static int
! 4605: istgt_iscsi_execute(CONN_Ptr conn, ISCSI_PDU_Ptr pdu)
! 4606: {
! 4607: int immediate, opcode;
! 4608: int rc;
! 4609:
! 4610: if (pdu == NULL)
! 4611: return -1;
! 4612:
! 4613: immediate = BGET8W(&conn->pdu.bhs.opcode, 6, 1);
! 4614: opcode = BGET8W(&conn->pdu.bhs.opcode, 5, 6);
! 4615:
! 4616: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI, "opcode %x\n", opcode);
! 4617: switch(opcode) {
! 4618: case ISCSI_OP_NOPOUT:
! 4619: rc = istgt_iscsi_op_nopout(conn, pdu);
! 4620: if (rc < 0) {
! 4621: ISTGT_ERRLOG("iscsi_op_nopout() failed\n");
! 4622: return -1;
! 4623: }
! 4624: break;
! 4625:
! 4626: case ISCSI_OP_SCSI:
! 4627: rc = istgt_iscsi_op_scsi(conn, pdu);
! 4628: if (rc < 0) {
! 4629: ISTGT_ERRLOG("iscsi_op_scsi() failed\n");
! 4630: return -1;
! 4631: }
! 4632: break;
! 4633:
! 4634: case ISCSI_OP_TASK:
! 4635: rc = istgt_iscsi_op_task(conn, pdu);
! 4636: if (rc < 0) {
! 4637: ISTGT_ERRLOG("iscsi_op_task() failed\n");
! 4638: return -1;
! 4639: }
! 4640: break;
! 4641:
! 4642: case ISCSI_OP_LOGIN:
! 4643: rc = istgt_iscsi_op_login(conn, pdu);
! 4644: if (rc < 0) {
! 4645: ISTGT_ERRLOG("iscsi_op_login() failed\n");
! 4646: return -1;
! 4647: }
! 4648: break;
! 4649:
! 4650: case ISCSI_OP_TEXT:
! 4651: rc = istgt_iscsi_op_text(conn, pdu);
! 4652: if (rc < 0) {
! 4653: ISTGT_ERRLOG("iscsi_op_text() failed\n");
! 4654: return -1;
! 4655: }
! 4656: break;
! 4657:
! 4658: case ISCSI_OP_LOGOUT:
! 4659: rc = istgt_iscsi_op_logout(conn, pdu);
! 4660: if (rc < 0) {
! 4661: ISTGT_ERRLOG("iscsi_op_logout() failed\n");
! 4662: return -1;
! 4663: }
! 4664: break;
! 4665:
! 4666: case ISCSI_OP_SCSI_DATAOUT:
! 4667: rc = istgt_iscsi_op_data(conn, pdu);
! 4668: if (rc < 0) {
! 4669: ISTGT_ERRLOG("iscsi_op_data() failed\n");
! 4670: return -1;
! 4671: }
! 4672: break;
! 4673:
! 4674: case ISCSI_OP_SNACK:
! 4675: ISTGT_ERRLOG("got SNACK\n");
! 4676: goto error_out;
! 4677: default:
! 4678: error_out:
! 4679: ISTGT_ERRLOG("unsupported opcode %x\n", opcode);
! 4680: rc = istgt_iscsi_reject(conn, pdu, 0x04);
! 4681: if (rc < 0) {
! 4682: ISTGT_ERRLOG("iscsi_reject() failed\n");
! 4683: return -1;
! 4684: }
! 4685: break;
! 4686: }
! 4687:
! 4688: return 0;
! 4689: }
! 4690:
! 4691: static void
! 4692: wait_all_task(CONN_Ptr conn)
! 4693: {
! 4694: ISTGT_LU_TASK_Ptr lu_task;
! 4695: #ifdef ISTGT_USE_KQUEUE
! 4696: int kq;
! 4697: struct kevent kev;
! 4698: struct timespec kev_timeout;
! 4699: #else
! 4700: struct pollfd fds[1];
! 4701: #endif /* ISTGT_USE_KQUEUE */
! 4702: int msec = 30 * 1000;
! 4703: int rc;
! 4704:
! 4705: if (conn->running_tasks == 0)
! 4706: return;
! 4707:
! 4708: #ifdef ISTGT_USE_KQUEUE
! 4709: kq = kqueue();
! 4710: if (kq == -1) {
! 4711: ISTGT_ERRLOG("kqueue() failed\n");
! 4712: return;
! 4713: }
! 4714: EV_SET(&kev, conn->task_pipe[0], EVFILT_READ, EV_ADD, 0, 0, NULL);
! 4715: rc = kevent(kq, &kev, 1, NULL, 0, NULL);
! 4716: if (rc == -1) {
! 4717: ISTGT_ERRLOG("kevent() failed\n");
! 4718: close(kq);
! 4719: return;
! 4720: }
! 4721: #else
! 4722: fds[0].fd = conn->task_pipe[0];
! 4723: fds[0].events = POLLIN;
! 4724: #endif /* ISTGT_USE_KQUEUE */
! 4725:
! 4726: /* wait all running tasks */
! 4727: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4728: "waiting task start (%d) (left %d tasks)\n",
! 4729: conn->id, conn->running_tasks);
! 4730: while (1) {
! 4731: #ifdef ISTGT_USE_KQUEUE
! 4732: kev_timeout.tv_sec = msec / 1000;
! 4733: kev_timeout.tv_nsec = (msec % 1000) * 1000000;
! 4734: rc = kevent(kq, NULL, 0, &kev, 1, &kev_timeout);
! 4735: if (rc == -1 && errno == EINTR) {
! 4736: continue;
! 4737: }
! 4738: if (rc == -1) {
! 4739: ISTGT_ERRLOG("kevent() failed\n");
! 4740: break;
! 4741: }
! 4742: if (rc == 0) {
! 4743: ISTGT_ERRLOG("waiting task timeout (left %d tasks)\n",
! 4744: conn->running_tasks);
! 4745: break;
! 4746: }
! 4747: #else
! 4748: rc = poll(fds, 1, msec);
! 4749: if (rc == -1 && errno == EINTR) {
! 4750: continue;
! 4751: }
! 4752: if (rc == -1) {
! 4753: ISTGT_ERRLOG("poll() failed\n");
! 4754: break;
! 4755: }
! 4756: if (rc == 0) {
! 4757: ISTGT_ERRLOG("waiting task timeout (left %d tasks)\n",
! 4758: conn->running_tasks);
! 4759: break;
! 4760: }
! 4761: #endif /* ISTGT_USE_KQUEUE */
! 4762:
! 4763: #ifdef ISTGT_USE_KQUEUE
! 4764: if (kev.ident == conn->task_pipe[0]) {
! 4765: if (kev.flags & (EV_EOF|EV_ERROR)) {
! 4766: break;
! 4767: }
! 4768: #else
! 4769: if (fds[0].revents & POLLHUP) {
! 4770: break;
! 4771: }
! 4772: if (fds[0].revents & POLLIN) {
! 4773: #endif /* ISTGT_USE_KQUEUE */
! 4774: char tmp[1];
! 4775:
! 4776: rc = read(conn->task_pipe[0], tmp, 1);
! 4777: if (rc < 0 || rc == 0 || rc != 1) {
! 4778: ISTGT_ERRLOG("read() failed\n");
! 4779: break;
! 4780: }
! 4781:
! 4782: MTX_LOCK(&conn->task_queue_mutex);
! 4783: lu_task = istgt_queue_dequeue(&conn->task_queue);
! 4784: MTX_UNLOCK(&conn->task_queue_mutex);
! 4785: if (lu_task != NULL) {
! 4786: if (lu_task->lu_cmd.W_bit) {
! 4787: /* write */
! 4788: if (lu_task->req_transfer_out != 0) {
! 4789: /* error transfer */
! 4790: lu_task->error = 1;
! 4791: lu_task->abort = 1;
! 4792: rc = pthread_cond_broadcast(&lu_task->trans_cond);
! 4793: if (rc != 0) {
! 4794: ISTGT_ERRLOG("cond_broadcast() failed\n");
! 4795: /* ignore error */
! 4796: }
! 4797: } else {
! 4798: if (lu_task->req_execute) {
! 4799: conn->running_tasks--;
! 4800: if (conn->running_tasks == 0) {
! 4801: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4802: "task cleanup finished\n");
! 4803: break;
! 4804: }
! 4805: }
! 4806: /* ignore response */
! 4807: rc = istgt_lu_destroy_task(lu_task);
! 4808: if (rc < 0) {
! 4809: ISTGT_ERRLOG("lu_destroy_task() failed\n");
! 4810: /* ignore error */
! 4811: }
! 4812: }
! 4813: } else {
! 4814: /* read or no data */
! 4815: /* ignore response */
! 4816: rc = istgt_lu_destroy_task(lu_task);
! 4817: if (rc < 0) {
! 4818: ISTGT_ERRLOG("lu_destroy_task() failed\n");
! 4819: /* ignore error */
! 4820: }
! 4821: }
! 4822: } else {
! 4823: ISTGT_ERRLOG("lu_task is NULL\n");
! 4824: break;
! 4825: }
! 4826: }
! 4827: }
! 4828:
! 4829: istgt_clear_all_transfer_task(conn);
! 4830: #ifdef ISTGT_USE_KQUEUE
! 4831: close(kq);
! 4832: #endif /* ISTGT_USE_KQUEUE */
! 4833: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4834: "waiting task end (%d) (left %d tasks)\n",
! 4835: conn->id, conn->running_tasks);
! 4836: }
! 4837:
! 4838: static void
! 4839: worker_cleanup(void *arg)
! 4840: {
! 4841: CONN_Ptr conn = (CONN_Ptr) arg;
! 4842: ISTGT_LU_Ptr lu;
! 4843: int rc;
! 4844:
! 4845: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "worker_cleanup\n");
! 4846: ISTGT_WARNLOG("force cleanup execute\n");
! 4847:
! 4848: /* cleanup */
! 4849: pthread_mutex_unlock(&conn->task_queue_mutex);
! 4850: pthread_mutex_unlock(&conn->result_queue_mutex);
! 4851: if (conn->sess != NULL) {
! 4852: if (conn->sess->lu != NULL) {
! 4853: pthread_mutex_unlock(&conn->sess->lu->mutex);
! 4854: }
! 4855: pthread_mutex_unlock(&conn->sess->mutex);
! 4856: }
! 4857: if (conn->exec_lu_task != NULL) {
! 4858: conn->exec_lu_task->error = 1;
! 4859: pthread_cond_broadcast(&conn->exec_lu_task->trans_cond);
! 4860: pthread_mutex_unlock(&conn->exec_lu_task->trans_mutex);
! 4861: }
! 4862: pthread_mutex_unlock(&conn->wpdu_mutex);
! 4863: pthread_mutex_unlock(&conn->r2t_mutex);
! 4864: pthread_mutex_unlock(&conn->istgt->mutex);
! 4865: pthread_mutex_unlock(&g_conns_mutex);
! 4866: pthread_mutex_unlock(&g_last_tsih_mutex);
! 4867:
! 4868: conn->state = CONN_STATE_EXITING;
! 4869: if (conn->sess != NULL) {
! 4870: SESS_MTX_LOCK(conn);
! 4871: lu = conn->sess->lu;
! 4872: if (lu != NULL && lu->queue_depth != 0) {
! 4873: rc = istgt_lu_clear_task_IT(conn, lu);
! 4874: if (rc < 0) {
! 4875: ISTGT_ERRLOG("lu_clear_task_IT() failed\n");
! 4876: }
! 4877: istgt_clear_all_transfer_task(conn);
! 4878: }
! 4879: SESS_MTX_UNLOCK(conn);
! 4880: }
! 4881: if (conn->pdu.copy_pdu == 0) {
! 4882: xfree(conn->pdu.ahs);
! 4883: conn->pdu.ahs = NULL;
! 4884: if (conn->pdu.data != conn->pdu.shortdata) {
! 4885: xfree(conn->pdu.data);
! 4886: }
! 4887: conn->pdu.data = NULL;
! 4888: }
! 4889: wait_all_task(conn);
! 4890: if (conn->use_sender) {
! 4891: pthread_cond_broadcast(&conn->result_queue_cond);
! 4892: pthread_join(conn->sender_thread, NULL);
! 4893: }
! 4894: close(conn->sock);
! 4895: #ifdef ISTGT_USE_KQUEUE
! 4896: close(conn->kq);
! 4897: conn->kq = -1;
! 4898: #endif /* ISTGT_USE_KQUEUE */
! 4899: sleep(1);
! 4900:
! 4901: /* cleanup conn & sess */
! 4902: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "cancel cleanup LOCK\n");
! 4903: MTX_LOCK(&g_conns_mutex);
! 4904: g_conns[conn->id] = NULL;
! 4905: istgt_remove_conn(conn);
! 4906: MTX_UNLOCK(&g_conns_mutex);
! 4907: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "cancel cleanup UNLOCK\n");
! 4908:
! 4909: return;
! 4910: }
! 4911:
! 4912: static void *
! 4913: sender(void *arg)
! 4914: {
! 4915: CONN_Ptr conn = (CONN_Ptr) arg;
! 4916: ISTGT_LU_TASK_Ptr lu_task;
! 4917: struct timespec abstime;
! 4918: time_t now;
! 4919: int rc;
! 4920:
! 4921: #ifdef HAVE_PTHREAD_SET_NAME_NP
! 4922: {
! 4923: char buf[MAX_TMPBUF];
! 4924: snprintf(buf, sizeof buf, "sendthread #%d", conn->id);
! 4925: pthread_set_name_np(conn->sender_thread, buf);
! 4926: }
! 4927: #endif
! 4928: memset(&abstime, 0, sizeof abstime);
! 4929: /* handle DATA-IN/SCSI status */
! 4930: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "sender loop start (%d)\n", conn->id);
! 4931: //MTX_LOCK(&conn->sender_mutex);
! 4932: while (1) {
! 4933: if (conn->state != CONN_STATE_RUNNING) {
! 4934: break;
! 4935: }
! 4936: MTX_LOCK(&conn->result_queue_mutex);
! 4937: lu_task = istgt_queue_dequeue(&conn->result_queue);
! 4938: if (lu_task == NULL) {
! 4939: now = time(NULL);
! 4940: abstime.tv_sec = now + conn->timeout;
! 4941: abstime.tv_nsec = 0;
! 4942: rc = pthread_cond_timedwait(&conn->result_queue_cond,
! 4943: &conn->result_queue_mutex, &abstime);
! 4944: if (rc == ETIMEDOUT) {
! 4945: /* nothing */
! 4946: }
! 4947: lu_task = istgt_queue_dequeue(&conn->result_queue);
! 4948: if (lu_task == NULL) {
! 4949: MTX_UNLOCK(&conn->result_queue_mutex);
! 4950: continue;
! 4951: }
! 4952: }
! 4953: MTX_UNLOCK(&conn->result_queue_mutex);
! 4954: /* send all responses */
! 4955: // MTX_LOCK(&conn->wpdu_mutex);
! 4956: do {
! 4957: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 4958: "task response CmdSN=%u\n", lu_task->lu_cmd.CmdSN);
! 4959: lu_task->lock = 1;
! 4960: if (lu_task->type == ISTGT_LU_TASK_RESPONSE) {
! 4961: /* send DATA-IN, SCSI status */
! 4962: rc = istgt_iscsi_task_response(conn, lu_task);
! 4963: if (rc < 0) {
! 4964: lu_task->error = 1;
! 4965: ISTGT_ERRLOG(
! 4966: "iscsi_task_response() failed on %s(%s)\n",
! 4967: conn->target_port, conn->initiator_port);
! 4968: break;
! 4969: }
! 4970: rc = istgt_lu_destroy_task(lu_task);
! 4971: if (rc < 0) {
! 4972: ISTGT_ERRLOG("lu_destroy_task() failed\n");
! 4973: break;
! 4974: }
! 4975: } else if (lu_task->type == ISTGT_LU_TASK_REQPDU) {
! 4976: /* send PDU */
! 4977: rc = istgt_iscsi_write_pdu_internal(lu_task->conn,
! 4978: lu_task->lu_cmd.pdu);
! 4979: if (rc < 0) {
! 4980: lu_task->error = 1;
! 4981: ISTGT_ERRLOG(
! 4982: "iscsi_write_pdu() failed on %s(%s)\n",
! 4983: lu_task->conn->target_port,
! 4984: lu_task->conn->initiator_port);
! 4985: break;
! 4986: }
! 4987: /* free allocated memory by caller */
! 4988: xfree(lu_task);
! 4989: } else {
! 4990: ISTGT_ERRLOG("Unknown task type %x\n", lu_task->type);
! 4991: rc = -1;
! 4992: }
! 4993: // conn is running?
! 4994: if (conn->state != CONN_STATE_RUNNING) {
! 4995: //ISTGT_WARNLOG("exit thread\n");
! 4996: break;
! 4997: }
! 4998: MTX_LOCK(&conn->result_queue_mutex);
! 4999: lu_task = istgt_queue_dequeue(&conn->result_queue);
! 5000: MTX_UNLOCK(&conn->result_queue_mutex);
! 5001: } while (lu_task != NULL);
! 5002: // MTX_UNLOCK(&conn->wpdu_mutex);
! 5003: }
! 5004: //MTX_UNLOCK(&conn->sender_mutex);
! 5005: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "sender loop ended (%d)\n", conn->id);
! 5006: return NULL;
! 5007: }
! 5008:
! 5009: static void *
! 5010: worker(void *arg)
! 5011: {
! 5012: CONN_Ptr conn = (CONN_Ptr) arg;
! 5013: ISTGT_LU_TASK_Ptr lu_task;
! 5014: ISTGT_LU_Ptr lu;
! 5015: ISCSI_PDU_Ptr pdu;
! 5016: sigset_t signew, sigold;
! 5017: #ifdef ISTGT_USE_KQUEUE
! 5018: int kq;
! 5019: struct kevent kev;
! 5020: struct timespec kev_timeout;
! 5021: #else
! 5022: struct pollfd fds[2];
! 5023: int nopin_timer;
! 5024: #endif /* ISTGT_USE_KQUEUE */
! 5025: int opcode;
! 5026: int rc;
! 5027:
! 5028: ISTGT_TRACELOG(ISTGT_TRACE_NET, "connect to %s:%s,%d\n",
! 5029: conn->portal.host, conn->portal.port, conn->portal.tag);
! 5030:
! 5031: #ifdef ISTGT_USE_KQUEUE
! 5032: kq = kqueue();
! 5033: if (kq == -1) {
! 5034: ISTGT_ERRLOG("kqueue() failed\n");
! 5035: return NULL;
! 5036: }
! 5037: conn->kq = kq;
! 5038: EV_SET(&kev, conn->sock, EVFILT_READ, EV_ADD, 0, 0, NULL);
! 5039: rc = kevent(kq, &kev, 1, NULL, 0, NULL);
! 5040: if (rc == -1) {
! 5041: ISTGT_ERRLOG("kevent() failed\n");
! 5042: close(kq);
! 5043: return NULL;
! 5044: }
! 5045: EV_SET(&kev, conn->task_pipe[0], EVFILT_READ, EV_ADD, 0, 0, NULL);
! 5046: rc = kevent(kq, &kev, 1, NULL, 0, NULL);
! 5047: if (rc == -1) {
! 5048: ISTGT_ERRLOG("kevent() failed\n");
! 5049: close(kq);
! 5050: return NULL;
! 5051: }
! 5052:
! 5053: EV_SET(&kev, SIGINT, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
! 5054: rc = kevent(kq, &kev, 1, NULL, 0, NULL);
! 5055: if (rc == -1) {
! 5056: ISTGT_ERRLOG("kevent() failed\n");
! 5057: close(kq);
! 5058: return NULL;
! 5059: }
! 5060: EV_SET(&kev, SIGTERM, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
! 5061: rc = kevent(kq, &kev, 1, NULL, 0, NULL);
! 5062: if (rc == -1) {
! 5063: ISTGT_ERRLOG("kevent() failed\n");
! 5064: close(kq);
! 5065: return NULL;
! 5066: }
! 5067: #else
! 5068: memset(&fds, 0, sizeof fds);
! 5069: fds[0].fd = conn->sock;
! 5070: fds[0].events = POLLIN;
! 5071: fds[1].fd = conn->task_pipe[0];
! 5072: fds[1].events = POLLIN;
! 5073:
! 5074: nopin_timer = conn->nopininterval;
! 5075: #endif /* ISTGT_USE_KQUEUE */
! 5076:
! 5077: conn->pdu.ahs = NULL;
! 5078: conn->pdu.data = NULL;
! 5079: conn->pdu.copy_pdu = 0;
! 5080: conn->state = CONN_STATE_RUNNING;
! 5081: conn->exec_lu_task = NULL;
! 5082: lu_task = NULL;
! 5083:
! 5084: pthread_cleanup_push(worker_cleanup, conn);
! 5085: pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
! 5086:
! 5087: conn->use_sender = 0;
! 5088: if (conn->istgt->swmode >= ISTGT_SWMODE_NORMAL) {
! 5089: /* create sender thread */
! 5090: #ifdef ISTGT_STACKSIZE
! 5091: rc = pthread_create(&conn->sender_thread, &conn->istgt->attr,
! 5092: &sender, (void *)conn);
! 5093: #else
! 5094: rc = pthread_create(&conn->sender_thread, NULL, &sender,
! 5095: (void *)conn);
! 5096: #endif
! 5097: if (rc != 0) {
! 5098: ISTGT_ERRLOG("pthread_create() failed\n");
! 5099: goto cleanup_exit;
! 5100: }
! 5101: conn->use_sender = 1;
! 5102: }
! 5103: conn->wsock = conn->sock;
! 5104:
! 5105: sigemptyset(&signew);
! 5106: sigemptyset(&sigold);
! 5107: sigaddset(&signew, ISTGT_SIGWAKEUP);
! 5108: pthread_sigmask(SIG_UNBLOCK, &signew, &sigold);
! 5109:
! 5110: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "loop start (%d)\n", conn->id);
! 5111: while (1) {
! 5112: /* check exit request */
! 5113: if (conn->sess != NULL) {
! 5114: SESS_MTX_LOCK(conn);
! 5115: lu = conn->sess->lu;
! 5116: SESS_MTX_UNLOCK(conn);
! 5117: } else {
! 5118: lu = NULL;
! 5119: }
! 5120: if (lu != NULL) {
! 5121: if (istgt_lu_get_state(lu) != ISTGT_STATE_RUNNING) {
! 5122: conn->state = CONN_STATE_EXITING;
! 5123: break;
! 5124: }
! 5125: } else {
! 5126: if (istgt_get_state(conn->istgt) != ISTGT_STATE_RUNNING) {
! 5127: conn->state = CONN_STATE_EXITING;
! 5128: break;
! 5129: }
! 5130: }
! 5131:
! 5132: pthread_testcancel();
! 5133: if (conn->state != CONN_STATE_RUNNING) {
! 5134: break;
! 5135: }
! 5136:
! 5137: #ifdef ISTGT_USE_KQUEUE
! 5138: ISTGT_TRACELOG(ISTGT_TRACE_NET,
! 5139: "kevent sock %d (timeout %dms)\n",
! 5140: conn->sock, conn->nopininterval);
! 5141: if (conn->nopininterval != 0) {
! 5142: kev_timeout.tv_sec = conn->nopininterval / 1000;
! 5143: kev_timeout.tv_nsec = (conn->nopininterval % 1000) * 1000000;
! 5144: } else {
! 5145: kev_timeout.tv_sec = DEFAULT_NOPININTERVAL;
! 5146: kev_timeout.tv_nsec = 0;
! 5147: }
! 5148: rc = kevent(kq, NULL, 0, &kev, 1, &kev_timeout);
! 5149: if (rc == -1 && errno == EINTR) {
! 5150: //ISTGT_ERRLOG("EINTR kevent\n");
! 5151: continue;
! 5152: }
! 5153: if (rc == -1) {
! 5154: ISTGT_ERRLOG("kevent() failed\n");
! 5155: break;
! 5156: }
! 5157: if (rc == 0) {
! 5158: /* idle timeout, send diagnosis packet */
! 5159: if (conn->nopininterval != 0) {
! 5160: rc = istgt_iscsi_send_nopin(conn);
! 5161: if (rc < 0) {
! 5162: ISTGT_ERRLOG("iscsi_send_nopin() failed\n");
! 5163: break;
! 5164: }
! 5165: }
! 5166: continue;
! 5167: }
! 5168: if (kev.filter == EVFILT_SIGNAL) {
! 5169: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "kevent SIGNAL\n");
! 5170: if (kev.ident == SIGINT || kev.ident == SIGTERM) {
! 5171: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5172: "kevent SIGNAL SIGINT/SIGTERM\n");
! 5173: break;
! 5174: }
! 5175: continue;
! 5176: }
! 5177: #else
! 5178: //ISTGT_TRACELOG(ISTGT_TRACE_NET, "poll sock %d\n", conn->sock);
! 5179: rc = poll(fds, 2, POLLWAIT);
! 5180: if (rc == -1 && errno == EINTR) {
! 5181: //ISTGT_ERRLOG("EINTR poll\n");
! 5182: continue;
! 5183: }
! 5184: if (rc == -1) {
! 5185: ISTGT_ERRLOG("poll() failed\n");
! 5186: break;
! 5187: }
! 5188: if (rc == 0) {
! 5189: /* no fds */
! 5190: if (nopin_timer > 0) {
! 5191: nopin_timer -= POLLWAIT;
! 5192: if (nopin_timer <= 0) {
! 5193: nopin_timer = conn->nopininterval;
! 5194: rc = istgt_iscsi_send_nopin(conn);
! 5195: if (rc < 0) {
! 5196: ISTGT_ERRLOG("iscsi_send_nopin() failed\n");
! 5197: break;
! 5198: }
! 5199: }
! 5200: }
! 5201: continue;
! 5202: }
! 5203: nopin_timer = conn->nopininterval;
! 5204: #endif /* ISTGT_USE_KQUEUE */
! 5205:
! 5206: /* on socket */
! 5207: #ifdef ISTGT_USE_KQUEUE
! 5208: if (kev.ident == conn->sock) {
! 5209: if (kev.flags & (EV_EOF|EV_ERROR)) {
! 5210: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5211: "kevent EOF/ERROR\n");
! 5212: break;
! 5213: }
! 5214: #else
! 5215: if (fds[0].revents & POLLHUP) {
! 5216: break;
! 5217: }
! 5218: if (fds[0].revents & POLLIN) {
! 5219: #endif /* ISTGT_USE_KQUEUE */
! 5220: conn->pdu.copy_pdu = 0;
! 5221: rc = istgt_iscsi_read_pdu(conn, &conn->pdu);
! 5222: if (rc < 0) {
! 5223: ISTGT_ERRLOG("conn->state = %d\n", conn->state);
! 5224: if (conn->state != CONN_STATE_RUNNING) {
! 5225: if (errno == EINPROGRESS) {
! 5226: sleep(1);
! 5227: continue;
! 5228: }
! 5229: if (errno == ECONNRESET
! 5230: || errno == ETIMEDOUT) {
! 5231: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5232: "iscsi_read_pdu() RESET/TIMEOUT\n");
! 5233: } else {
! 5234: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5235: "iscsi_read_pdu() EOF\n");
! 5236: }
! 5237: break;
! 5238: }
! 5239: ISTGT_ERRLOG("iscsi_read_pdu() failed\n");
! 5240: break;
! 5241: }
! 5242: execute_pdu:
! 5243: opcode = BGET8W(&conn->pdu.bhs.opcode, 5, 6);
! 5244:
! 5245: #if 0
! 5246: pthread_testcancel();
! 5247: #endif
! 5248: if (conn->state != CONN_STATE_RUNNING) {
! 5249: break;
! 5250: }
! 5251:
! 5252: if (g_trace_flag) {
! 5253: if (conn->sess != NULL) {
! 5254: SESS_MTX_LOCK(conn);
! 5255: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 5256: "isid=%"PRIx64", tsih=%u, cid=%u, op=%x\n",
! 5257: conn->sess->isid, conn->sess->tsih,
! 5258: conn->cid, opcode);
! 5259: SESS_MTX_UNLOCK(conn);
! 5260: } else {
! 5261: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 5262: "isid=xxx, tsih=xxx, cid=%u, op=%x\n",
! 5263: conn->cid, opcode);
! 5264: }
! 5265: }
! 5266: rc = istgt_iscsi_execute(conn, &conn->pdu);
! 5267: if (rc < 0) {
! 5268: ISTGT_ERRLOG("iscsi_execute() failed on %s(%s)\n",
! 5269: conn->target_port, conn->initiator_port);
! 5270: break;
! 5271: }
! 5272: if (g_trace_flag) {
! 5273: if (conn->sess != NULL) {
! 5274: SESS_MTX_LOCK(conn);
! 5275: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 5276: "isid=%"PRIx64", tsih=%u, cid=%u, op=%x complete\n",
! 5277: conn->sess->isid, conn->sess->tsih,
! 5278: conn->cid, opcode);
! 5279: SESS_MTX_UNLOCK(conn);
! 5280: } else {
! 5281: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 5282: "isid=xxx, tsih=xxx, cid=%u, op=%x complete\n",
! 5283: conn->cid, opcode);
! 5284: }
! 5285: }
! 5286:
! 5287: if (opcode == ISCSI_OP_LOGOUT) {
! 5288: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI, "logout received\n");
! 5289: break;
! 5290: }
! 5291:
! 5292: if (conn->pdu.copy_pdu == 0) {
! 5293: xfree(conn->pdu.ahs);
! 5294: conn->pdu.ahs = NULL;
! 5295: if (conn->pdu.data != conn->pdu.shortdata) {
! 5296: xfree(conn->pdu.data);
! 5297: }
! 5298: conn->pdu.data = NULL;
! 5299: }
! 5300:
! 5301: /* execute pending PDUs */
! 5302: pdu = istgt_queue_dequeue(&conn->pending_pdus);
! 5303: if (pdu != NULL) {
! 5304: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5305: "execute pending PDU\n");
! 5306: rc = istgt_iscsi_copy_pdu(&conn->pdu, pdu);
! 5307: conn->pdu.copy_pdu = 0;
! 5308: xfree(pdu);
! 5309: goto execute_pdu;
! 5310: }
! 5311:
! 5312: #if 0
! 5313: /* retry read/PDUs */
! 5314: continue;
! 5315: #endif
! 5316: }
! 5317:
! 5318: /* execute on task queue */
! 5319: #ifdef ISTGT_USE_KQUEUE
! 5320: if (kev.ident == conn->task_pipe[0]) {
! 5321: if (kev.flags & (EV_EOF|EV_ERROR)) {
! 5322: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5323: "kevent EOF/ERROR\n");
! 5324: break;
! 5325: }
! 5326: #else
! 5327: if (fds[1].revents & POLLHUP) {
! 5328: break;
! 5329: }
! 5330: if (fds[1].revents & POLLIN) {
! 5331: #endif /* ISTGT_USE_KQUEUE */
! 5332: char tmp[1];
! 5333:
! 5334: //ISTGT_TRACELOG(ISTGT_TRACE_SCSI, "Queue Task START\n");
! 5335:
! 5336: rc = read(conn->task_pipe[0], tmp, 1);
! 5337: if (rc < 0 || rc == 0 || rc != 1) {
! 5338: ISTGT_ERRLOG("read() failed\n");
! 5339: break;
! 5340: }
! 5341:
! 5342: /* DATA-IN/OUT */
! 5343: MTX_LOCK(&conn->task_queue_mutex);
! 5344: rc = istgt_queue_count(&conn->task_queue);
! 5345: lu_task = istgt_queue_dequeue(&conn->task_queue);
! 5346: MTX_UNLOCK(&conn->task_queue_mutex);
! 5347: if (lu_task != NULL) {
! 5348: if (conn->exec_lu_task != NULL) {
! 5349: ISTGT_ERRLOG("task is overlapped (CmdSN=%u, %u)\n",
! 5350: conn->exec_lu_task->lu_cmd.CmdSN,
! 5351: lu_task->lu_cmd.CmdSN);
! 5352: break;
! 5353: }
! 5354: conn->exec_lu_task = lu_task;
! 5355: if (lu_task->lu_cmd.W_bit) {
! 5356: /* write */
! 5357: if (lu_task->req_transfer_out == 0) {
! 5358: if (lu_task->req_execute) {
! 5359: if (conn->running_tasks > 0) {
! 5360: conn->running_tasks--;
! 5361: } else {
! 5362: ISTGT_ERRLOG("running no task\n");
! 5363: }
! 5364: }
! 5365: rc = istgt_iscsi_task_response(conn, lu_task);
! 5366: if (rc < 0) {
! 5367: lu_task->error = 1;
! 5368: ISTGT_ERRLOG("iscsi_task_response() failed on %s(%s)\n",
! 5369: conn->target_port,
! 5370: conn->initiator_port);
! 5371: break;
! 5372: }
! 5373: rc = istgt_lu_destroy_task(lu_task);
! 5374: if (rc < 0) {
! 5375: ISTGT_ERRLOG("lu_destroy_task() failed\n");
! 5376: break;
! 5377: }
! 5378: lu_task = NULL;
! 5379: conn->exec_lu_task = NULL;
! 5380: } else {
! 5381: MTX_LOCK(&lu_task->trans_mutex);
! 5382: //ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5383: // "Task Write Trans START\n");
! 5384: rc = istgt_iscsi_task_transfer_out(conn, lu_task);
! 5385: if (rc < 0) {
! 5386: lu_task->error = 1;
! 5387: MTX_UNLOCK(&lu_task->trans_mutex);
! 5388: ISTGT_ERRLOG("iscsi_task_transfer_out() failed on %s(%s)\n",
! 5389: conn->target_port,
! 5390: conn->initiator_port);
! 5391: break;
! 5392: }
! 5393: //ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5394: // "Task Write Trans END\n");
! 5395:
! 5396: lu_task->req_transfer_out = 0;
! 5397:
! 5398: /* need response after execution */
! 5399: lu_task->req_execute = 1;
! 5400: if (conn->use_sender == 0) {
! 5401: conn->running_tasks++;
! 5402: }
! 5403: MTX_UNLOCK(&lu_task->trans_mutex);
! 5404:
! 5405: rc = pthread_cond_broadcast(&lu_task->trans_cond);
! 5406: if (rc != 0) {
! 5407: //MTX_UNLOCK(&lu_task->trans_mutex);
! 5408: ISTGT_ERRLOG("cond_broadcast() failed\n");
! 5409: break;
! 5410: }
! 5411: lu_task = NULL;
! 5412: conn->exec_lu_task = NULL;
! 5413: }
! 5414: } else {
! 5415: /* read or no data */
! 5416: rc = istgt_iscsi_task_response(conn, lu_task);
! 5417: if (rc < 0) {
! 5418: lu_task->error = 1;
! 5419: ISTGT_ERRLOG("iscsi_task_response() failed on %s(%s)\n",
! 5420: conn->target_port,
! 5421: conn->initiator_port);
! 5422: break;
! 5423: }
! 5424: rc = istgt_lu_destroy_task(lu_task);
! 5425: if (rc < 0) {
! 5426: ISTGT_ERRLOG("lu_destroy_task() failed\n");
! 5427: break;
! 5428: }
! 5429: lu_task = NULL;
! 5430: conn->exec_lu_task = NULL;
! 5431: }
! 5432: }
! 5433: /* XXX PDUs in DATA-OUT? */
! 5434: pdu = istgt_queue_dequeue(&conn->pending_pdus);
! 5435: if (pdu != NULL) {
! 5436: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 5437: "pending in task\n");
! 5438: rc = istgt_iscsi_copy_pdu(&conn->pdu, pdu);
! 5439: conn->pdu.copy_pdu = 0;
! 5440: xfree(pdu);
! 5441: #ifdef ISTGT_USE_KQUEUE
! 5442: kev.ident = -1;
! 5443: #else
! 5444: fds[1].revents &= ~POLLIN;
! 5445: #endif /* ISTGT_USE_KQUEUE */
! 5446: goto execute_pdu;
! 5447: }
! 5448: }
! 5449: }
! 5450: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "loop ended (%d)\n", conn->id);
! 5451:
! 5452: cleanup_exit:
! 5453: ;
! 5454: pthread_cleanup_pop(0);
! 5455: conn->state = CONN_STATE_EXITING;
! 5456: if (conn->sess != NULL) {
! 5457: SESS_MTX_LOCK(conn);
! 5458: lu = conn->sess->lu;
! 5459: if (lu != NULL && lu->queue_depth != 0) {
! 5460: rc = istgt_lu_clear_task_IT(conn, lu);
! 5461: if (rc < 0) {
! 5462: ISTGT_ERRLOG("lu_clear_task_IT() failed\n");
! 5463: }
! 5464: istgt_clear_all_transfer_task(conn);
! 5465: }
! 5466: SESS_MTX_UNLOCK(conn);
! 5467: }
! 5468: if (conn->pdu.copy_pdu == 0) {
! 5469: xfree(conn->pdu.ahs);
! 5470: conn->pdu.ahs = NULL;
! 5471: if (conn->pdu.data != conn->pdu.shortdata) {
! 5472: xfree(conn->pdu.data);
! 5473: }
! 5474: conn->pdu.data = NULL;
! 5475: }
! 5476: wait_all_task(conn);
! 5477:
! 5478: if (conn->use_sender) {
! 5479: /* stop sender thread */
! 5480: rc = pthread_cond_broadcast(&conn->result_queue_cond);
! 5481: if (rc != 0) {
! 5482: ISTGT_ERRLOG("cond_broadcast() failed\n");
! 5483: /* ignore errors */
! 5484: }
! 5485: rc = pthread_join(conn->sender_thread, NULL);
! 5486: if (rc != 0) {
! 5487: ISTGT_ERRLOG("pthread_join() failed\n");
! 5488: /* ignore errors */
! 5489: }
! 5490: }
! 5491:
! 5492: close(conn->sock);
! 5493: #ifdef ISTGT_USE_KQUEUE
! 5494: close(kq);
! 5495: conn->kq = -1;
! 5496: #endif /* ISTGT_USE_KQUEUE */
! 5497: sleep(1);
! 5498: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "worker %d end\n", conn->id);
! 5499:
! 5500: /* cleanup conn & sess */
! 5501: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "cleanup LOCK\n");
! 5502: MTX_LOCK(&g_conns_mutex);
! 5503: g_conns[conn->id] = NULL;
! 5504: istgt_remove_conn(conn);
! 5505: MTX_UNLOCK(&g_conns_mutex);
! 5506: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "cleanup UNLOCK\n");
! 5507:
! 5508: return NULL;
! 5509: }
! 5510:
! 5511: int
! 5512: istgt_create_conn(ISTGT_Ptr istgt, PORTAL_Ptr portal, int sock, struct sockaddr *sa, socklen_t salen)
! 5513: {
! 5514: char buf[MAX_TMPBUF];
! 5515: CONN_Ptr conn;
! 5516: int rc;
! 5517: int i;
! 5518:
! 5519: conn = xmalloc(sizeof *conn);
! 5520: memset(conn, 0, sizeof *conn);
! 5521:
! 5522: conn->istgt = istgt;
! 5523: MTX_LOCK(&istgt->mutex);
! 5524: conn->timeout = istgt->timeout;
! 5525: conn->nopininterval = istgt->nopininterval;
! 5526: conn->nopininterval *= 1000; /* sec. to msec. */
! 5527: conn->max_r2t = istgt->maxr2t;
! 5528: conn->TargetMaxRecvDataSegmentLength = istgt->MaxRecvDataSegmentLength;
! 5529: MTX_UNLOCK(&istgt->mutex);
! 5530: conn->MaxRecvDataSegmentLength = 8192; // RFC3720(12.12)
! 5531: if (conn->TargetMaxRecvDataSegmentLength
! 5532: < conn->MaxRecvDataSegmentLength) {
! 5533: conn->TargetMaxRecvDataSegmentLength
! 5534: = conn->MaxRecvDataSegmentLength;
! 5535: }
! 5536: conn->MaxOutstandingR2T = 1;
! 5537: conn->FirstBurstLength = DEFAULT_FIRSTBURSTLENGTH;
! 5538: conn->MaxBurstLength = DEFAULT_MAXBURSTLENGTH;
! 5539:
! 5540: conn->portal.label = xstrdup(portal->label);
! 5541: conn->portal.host = xstrdup(portal->host);
! 5542: conn->portal.port = xstrdup(portal->port);
! 5543: conn->portal.idx = portal->idx;
! 5544: conn->portal.tag = portal->tag;
! 5545: conn->portal.sock = -1;
! 5546: conn->sock = sock;
! 5547: conn->wsock = -1;
! 5548: #ifdef ISTGT_USE_KQUEUE
! 5549: conn->kq = -1;
! 5550: #endif /* ISTGT_USE_KQUEUE */
! 5551: conn->use_sender = 0;
! 5552:
! 5553: conn->sess = NULL;
! 5554: conn->params = NULL;
! 5555: conn->state = CONN_STATE_INVALID;
! 5556: conn->exec_logout = 0;
! 5557: conn->max_pending = 0;
! 5558: conn->queue_depth = 0;
! 5559: conn->pending_r2t = 0;
! 5560: conn->header_digest = 0;
! 5561: conn->data_digest = 0;
! 5562: conn->full_feature = 0;
! 5563: conn->login_phase = ISCSI_LOGIN_PHASE_NONE;
! 5564: conn->auth.user = NULL;
! 5565: conn->auth.secret = NULL;
! 5566: conn->auth.muser = NULL;
! 5567: conn->auth.msecret = NULL;
! 5568: conn->authenticated = 0;
! 5569: conn->req_auth = 0;
! 5570: conn->req_mutual = 0;
! 5571: istgt_queue_init(&conn->pending_pdus);
! 5572: conn->r2t_tasks = xmalloc (sizeof *conn->r2t_tasks
! 5573: * (conn->max_r2t + 1));
! 5574: for (i = 0; i < (conn->max_r2t + 1); i++) {
! 5575: conn->r2t_tasks[i] = NULL;
! 5576: }
! 5577: conn->task_pipe[0] = -1;
! 5578: conn->task_pipe[1] = -1;
! 5579: conn->max_task_queue = MAX_LU_QUEUE_DEPTH;
! 5580: istgt_queue_init(&conn->task_queue);
! 5581: istgt_queue_init(&conn->result_queue);
! 5582: conn->exec_lu_task = NULL;
! 5583: conn->running_tasks = 0;
! 5584:
! 5585: memset(conn->initiator_addr, 0, sizeof conn->initiator_addr);
! 5586: memset(conn->target_addr, 0, sizeof conn->target_addr);
! 5587:
! 5588: switch (sa->sa_family) {
! 5589: case AF_INET6:
! 5590: conn->initiator_family = AF_INET6;
! 5591: rc = istgt_getaddr(sock, conn->target_addr,
! 5592: sizeof conn->target_addr,
! 5593: conn->initiator_addr, sizeof conn->initiator_addr);
! 5594: if (rc < 0) {
! 5595: ISTGT_ERRLOG("istgt_getaddr() failed\n");
! 5596: goto error_return;
! 5597: }
! 5598: break;
! 5599: case AF_INET:
! 5600: conn->initiator_family = AF_INET;
! 5601: rc = istgt_getaddr(sock, conn->target_addr,
! 5602: sizeof conn->target_addr,
! 5603: conn->initiator_addr, sizeof conn->initiator_addr);
! 5604: if (rc < 0) {
! 5605: ISTGT_ERRLOG("istgt_getaddr() failed\n");
! 5606: goto error_return;
! 5607: }
! 5608: break;
! 5609: default:
! 5610: ISTGT_ERRLOG("unsupported family\n");
! 5611: goto error_return;
! 5612: }
! 5613: printf("sock=%d, addr=%s, peer=%s\n",
! 5614: sock, conn->target_addr,
! 5615: conn->initiator_addr);
! 5616:
! 5617: /* wildcard? */
! 5618: if (strcasecmp(conn->portal.host, "[::]") == 0
! 5619: || strcasecmp(conn->portal.host, "[*]") == 0) {
! 5620: if (conn->initiator_family != AF_INET6) {
! 5621: ISTGT_ERRLOG("address family error\n");
! 5622: goto error_return;
! 5623: }
! 5624: snprintf(buf, sizeof buf, "[%s]", conn->target_addr);
! 5625: xfree(conn->portal.host);
! 5626: conn->portal.host = xstrdup(buf);
! 5627: } else if (strcasecmp(conn->portal.host, "0.0.0.0") == 0
! 5628: || strcasecmp(conn->portal.host, "*") == 0) {
! 5629: if (conn->initiator_family != AF_INET) {
! 5630: ISTGT_ERRLOG("address family error\n");
! 5631: goto error_return;
! 5632: }
! 5633: snprintf(buf, sizeof buf, "%s", conn->target_addr);
! 5634: xfree(conn->portal.host);
! 5635: conn->portal.host = xstrdup(buf);
! 5636: }
! 5637:
! 5638: memset(conn->initiator_name, 0, sizeof conn->initiator_name);
! 5639: memset(conn->target_name, 0, sizeof conn->target_name);
! 5640: memset(conn->initiator_port, 0, sizeof conn->initiator_port);
! 5641: memset(conn->target_port, 0, sizeof conn->target_port);
! 5642:
! 5643: /* set timeout msec. */
! 5644: rc = istgt_set_recvtimeout(conn->sock, conn->timeout * 1000);
! 5645: if (rc != 0) {
! 5646: ISTGT_ERRLOG("istgt_set_recvtimeo() failed\n");
! 5647: goto error_return;
! 5648: }
! 5649: rc = istgt_set_sendtimeout(conn->sock, conn->timeout * 1000);
! 5650: if (rc != 0) {
! 5651: ISTGT_ERRLOG("istgt_set_sendtimeo() failed\n");
! 5652: goto error_return;
! 5653: }
! 5654:
! 5655: rc = pipe(conn->task_pipe);
! 5656: if (rc != 0) {
! 5657: ISTGT_ERRLOG("pipe() failed\n");
! 5658: conn->task_pipe[0] = -1;
! 5659: conn->task_pipe[1] = -1;
! 5660: goto error_return;
! 5661: }
! 5662: rc = pthread_mutex_init(&conn->task_queue_mutex, NULL);
! 5663: if (rc != 0) {
! 5664: ISTGT_ERRLOG("mutex_init() failed\n");
! 5665: goto error_return;
! 5666: }
! 5667: rc = pthread_mutex_init(&conn->result_queue_mutex, NULL);
! 5668: if (rc != 0) {
! 5669: ISTGT_ERRLOG("mutex_init() failed\n");
! 5670: goto error_return;
! 5671: }
! 5672: rc = pthread_cond_init(&conn->result_queue_cond, NULL);
! 5673: if (rc != 0) {
! 5674: ISTGT_ERRLOG("cond_init() failed\n");
! 5675: goto error_return;
! 5676: }
! 5677: rc = pthread_mutex_init(&conn->wpdu_mutex, NULL);
! 5678: if (rc != 0) {
! 5679: ISTGT_ERRLOG("mutex_init() failed\n");
! 5680: goto error_return;
! 5681: }
! 5682: rc = pthread_cond_init(&conn->wpdu_cond, NULL);
! 5683: if (rc != 0) {
! 5684: ISTGT_ERRLOG("cond_init() failed\n");
! 5685: goto error_return;
! 5686: }
! 5687: rc = pthread_mutex_init(&conn->r2t_mutex, NULL);
! 5688: if (rc != 0) {
! 5689: ISTGT_ERRLOG("mutex_init() failed\n");
! 5690: goto error_return;
! 5691: }
! 5692: rc = pthread_mutex_init(&conn->sender_mutex, NULL);
! 5693: if (rc != 0) {
! 5694: ISTGT_ERRLOG("mutex_init() failed\n");
! 5695: goto error_return;
! 5696: }
! 5697: rc = pthread_cond_init(&conn->sender_cond, NULL);
! 5698: if (rc != 0) {
! 5699: ISTGT_ERRLOG("cond_init() failed\n");
! 5700: goto error_return;
! 5701: }
! 5702:
! 5703: /* set default params */
! 5704: rc = istgt_iscsi_conn_params_init(&conn->params);
! 5705: if (rc < 0) {
! 5706: ISTGT_ERRLOG("iscsi_conn_params_init() failed\n");
! 5707: goto error_return;
! 5708: }
! 5709: /* replace with config value */
! 5710: rc = istgt_iscsi_param_set_int(conn->params,
! 5711: "MaxRecvDataSegmentLength",
! 5712: conn->MaxRecvDataSegmentLength);
! 5713: if (rc < 0) {
! 5714: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5715: goto error_return;
! 5716: }
! 5717:
! 5718: conn->shortpdusize = ISTGT_SHORTPDUSIZE;
! 5719: conn->shortpdu = xmalloc(conn->shortpdusize);
! 5720:
! 5721: conn->iobufsize = ISTGT_IOBUFSIZE;
! 5722: conn->iobuf = xmalloc(conn->iobufsize);
! 5723: conn->snsbufsize = ISTGT_SNSBUFSIZE;
! 5724: conn->snsbuf = xmalloc(conn->snsbufsize);
! 5725:
! 5726: if (conn->MaxRecvDataSegmentLength < 8192) {
! 5727: conn->recvbufsize = 8192;
! 5728: conn->sendbufsize = 8192;
! 5729: } else {
! 5730: conn->recvbufsize = conn->MaxRecvDataSegmentLength;
! 5731: conn->sendbufsize = conn->MaxRecvDataSegmentLength;
! 5732: }
! 5733: conn->recvbuf = xmalloc(conn->recvbufsize);
! 5734: conn->sendbuf = xmalloc(conn->sendbufsize);
! 5735:
! 5736: conn->worksize = 0;
! 5737: conn->workbuf = NULL;
! 5738:
! 5739: /* register global */
! 5740: rc = -1;
! 5741: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "register global LOCK\n");
! 5742: MTX_LOCK(&g_conns_mutex);
! 5743: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "register global LOCKED\n");
! 5744: for (i = 0; i < g_nconns; i++) {
! 5745: if (g_conns[i] == NULL) {
! 5746: g_conns[i] = conn;
! 5747: conn->id = i;
! 5748: rc = 0;
! 5749: break;
! 5750: }
! 5751: }
! 5752: MTX_UNLOCK(&g_conns_mutex);
! 5753: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "register global UNLOCK\n");
! 5754: if (rc < 0) {
! 5755: ISTGT_ERRLOG("no free conn slot available\n");
! 5756: error_return:
! 5757: if (conn->task_pipe[0] != -1)
! 5758: close(conn->task_pipe[0]);
! 5759: if (conn->task_pipe[1] != -1)
! 5760: close(conn->task_pipe[1]);
! 5761: istgt_iscsi_param_free(conn->params);
! 5762: istgt_queue_destroy(&conn->pending_pdus);
! 5763: istgt_queue_destroy(&conn->task_queue);
! 5764: xfree(conn->portal.label);
! 5765: xfree(conn->portal.host);
! 5766: xfree(conn->portal.port);
! 5767: xfree(conn->iobuf);
! 5768: xfree(conn->snsbuf);
! 5769: xfree(conn->recvbuf);
! 5770: xfree(conn->sendbuf);
! 5771: xfree(conn);
! 5772: return -1;
! 5773: }
! 5774:
! 5775: /* create new thread */
! 5776: #ifdef ISTGT_STACKSIZE
! 5777: rc = pthread_create(&conn->thread, &istgt->attr, &worker, (void *)conn);
! 5778: #else
! 5779: rc = pthread_create(&conn->thread, NULL, &worker, (void *)conn);
! 5780: #endif /* ISTGT_STACKSIZE */
! 5781: if (rc != 0) {
! 5782: ISTGT_ERRLOG("pthread_create() failed\n");
! 5783: goto error_return;
! 5784: }
! 5785: rc = pthread_detach(conn->thread);
! 5786: if (rc != 0) {
! 5787: ISTGT_ERRLOG("pthread_detach() failed\n");
! 5788: goto error_return;
! 5789: }
! 5790: #ifdef HAVE_PTHREAD_SET_NAME_NP
! 5791: snprintf(buf, sizeof buf, "connthread #%d", conn->id);
! 5792: pthread_set_name_np(conn->thread, buf);
! 5793: #endif
! 5794:
! 5795: return 0;
! 5796: }
! 5797:
! 5798: int
! 5799: istgt_create_sess(ISTGT_Ptr istgt, CONN_Ptr conn, ISTGT_LU_Ptr lu)
! 5800: {
! 5801: SESS_Ptr sess;
! 5802: int rc;
! 5803:
! 5804: sess = xmalloc(sizeof *sess);
! 5805: memset(sess, 0, sizeof *sess);
! 5806:
! 5807: /* configuration values */
! 5808: MTX_LOCK(&istgt->mutex);
! 5809: if (lu != NULL) {
! 5810: MTX_LOCK(&lu->mutex);
! 5811: }
! 5812: sess->MaxConnections = istgt->MaxConnections;
! 5813: if (lu != NULL) {
! 5814: sess->MaxOutstandingR2T = lu->MaxOutstandingR2T;
! 5815: } else {
! 5816: sess->MaxOutstandingR2T = istgt->MaxOutstandingR2T;
! 5817: }
! 5818: #if 0
! 5819: if (sess->MaxOutstandingR2T > conn->max_r2t) {
! 5820: if (conn->max_r2t > 0) {
! 5821: sess->MaxOutstandingR2T = conn->max_r2t;
! 5822: } else {
! 5823: sess->MaxOutstandingR2T = 1;
! 5824: }
! 5825: }
! 5826: #else
! 5827: if (sess->MaxOutstandingR2T < 1) {
! 5828: sess->MaxOutstandingR2T = 1;
! 5829: }
! 5830: /* limit up to MaxOutstandingR2T */
! 5831: if (sess->MaxOutstandingR2T < conn->max_r2t) {
! 5832: conn->max_r2t = sess->MaxOutstandingR2T;
! 5833: }
! 5834: #endif
! 5835: if (lu != NULL) {
! 5836: sess->DefaultTime2Wait = lu->DefaultTime2Wait;
! 5837: sess->DefaultTime2Retain = lu->DefaultTime2Retain;
! 5838: sess->FirstBurstLength = lu->FirstBurstLength;
! 5839: sess->MaxBurstLength = lu->MaxBurstLength;
! 5840: conn->MaxRecvDataSegmentLength
! 5841: = lu->MaxRecvDataSegmentLength;
! 5842: sess->InitialR2T = lu->InitialR2T;
! 5843: sess->ImmediateData = lu->ImmediateData;
! 5844: sess->DataPDUInOrder = lu->DataPDUInOrder;
! 5845: sess->DataSequenceInOrder = lu->DataSequenceInOrder;
! 5846: sess->ErrorRecoveryLevel = lu->ErrorRecoveryLevel;
! 5847: } else {
! 5848: sess->DefaultTime2Wait = istgt->DefaultTime2Wait;
! 5849: sess->DefaultTime2Retain = istgt->DefaultTime2Retain;
! 5850: sess->FirstBurstLength = istgt->FirstBurstLength;
! 5851: sess->MaxBurstLength = istgt->MaxBurstLength;
! 5852: conn->MaxRecvDataSegmentLength
! 5853: = istgt->MaxRecvDataSegmentLength;
! 5854: sess->InitialR2T = istgt->InitialR2T;
! 5855: sess->ImmediateData = istgt->ImmediateData;
! 5856: sess->DataPDUInOrder = istgt->DataPDUInOrder;
! 5857: sess->DataSequenceInOrder = istgt->DataSequenceInOrder;
! 5858: sess->ErrorRecoveryLevel = istgt->ErrorRecoveryLevel;
! 5859: }
! 5860: if (lu != NULL) {
! 5861: MTX_UNLOCK(&lu->mutex);
! 5862: }
! 5863: MTX_UNLOCK(&istgt->mutex);
! 5864:
! 5865: sess->initiator_port = xstrdup(conn->initiator_port);
! 5866: sess->target_name = xstrdup(conn->target_name);
! 5867: sess->tag = conn->portal.tag;
! 5868:
! 5869: sess->max_conns = sess->MaxConnections;
! 5870: sess->conns = xmalloc(sizeof *sess->conns * sess->max_conns);
! 5871: memset(sess->conns, 0, sizeof *sess->conns * sess->max_conns);
! 5872: sess->connections = 0;
! 5873:
! 5874: sess->conns[sess->connections] = conn;
! 5875: sess->connections++;
! 5876:
! 5877: sess->req_mcs_cond = 0;
! 5878: sess->params = NULL;
! 5879: sess->lu = NULL;
! 5880: sess->isid = 0;
! 5881: sess->tsih = 0;
! 5882:
! 5883: sess->initial_r2t = 0;
! 5884: sess->immediate_data = 0;
! 5885:
! 5886: rc = pthread_mutex_init(&sess->mutex, NULL);
! 5887: if (rc != 0) {
! 5888: ISTGT_ERRLOG("mutex_init() failed\n");
! 5889: error_return:
! 5890: istgt_iscsi_param_free(sess->params);
! 5891: xfree(sess->initiator_port);
! 5892: xfree(sess->target_name);
! 5893: xfree(sess->conns);
! 5894: xfree(sess);
! 5895: conn->sess = NULL;
! 5896: return -1;
! 5897: }
! 5898: rc = pthread_cond_init(&sess->mcs_cond, NULL);
! 5899: if (rc != 0) {
! 5900: ISTGT_ERRLOG("cond_init() failed\n");
! 5901: goto error_return;
! 5902: }
! 5903:
! 5904: /* set default params */
! 5905: rc = istgt_iscsi_sess_params_init(&sess->params);
! 5906: if (rc < 0) {
! 5907: ISTGT_ERRLOG("iscsi_sess_params_init() failed\n");
! 5908: goto error_return;
! 5909: }
! 5910: /* replace with config value */
! 5911: rc = istgt_iscsi_param_set_int(sess->params,
! 5912: "MaxConnections",
! 5913: sess->MaxConnections);
! 5914: if (rc < 0) {
! 5915: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5916: goto error_return;
! 5917: }
! 5918: rc = istgt_iscsi_param_set_int(sess->params,
! 5919: "MaxOutstandingR2T",
! 5920: sess->MaxOutstandingR2T);
! 5921: if (rc < 0) {
! 5922: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5923: goto error_return;
! 5924: }
! 5925: rc = istgt_iscsi_param_set_int(sess->params,
! 5926: "DefaultTime2Wait",
! 5927: sess->DefaultTime2Wait);
! 5928: if (rc < 0) {
! 5929: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5930: goto error_return;
! 5931: }
! 5932: rc = istgt_iscsi_param_set_int(sess->params,
! 5933: "DefaultTime2Retain",
! 5934: sess->DefaultTime2Retain);
! 5935: if (rc < 0) {
! 5936: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5937: goto error_return;
! 5938: }
! 5939: rc = istgt_iscsi_param_set_int(sess->params,
! 5940: "FirstBurstLength",
! 5941: sess->FirstBurstLength);
! 5942: if (rc < 0) {
! 5943: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5944: goto error_return;
! 5945: }
! 5946: rc = istgt_iscsi_param_set_int(sess->params,
! 5947: "MaxBurstLength",
! 5948: sess->MaxBurstLength);
! 5949: if (rc < 0) {
! 5950: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5951: goto error_return;
! 5952: }
! 5953: rc = istgt_iscsi_param_set(sess->params,
! 5954: "InitialR2T",
! 5955: sess->InitialR2T ? "Yes" : "No");
! 5956: if (rc < 0) {
! 5957: ISTGT_ERRLOG("iscsi_param_set() failed\n");
! 5958: goto error_return;
! 5959: }
! 5960: rc = istgt_iscsi_param_set(sess->params,
! 5961: "ImmediateData",
! 5962: sess->ImmediateData ? "Yes" : "No");
! 5963: if (rc < 0) {
! 5964: ISTGT_ERRLOG("iscsi_param_set() failed\n");
! 5965: goto error_return;
! 5966: }
! 5967: rc = istgt_iscsi_param_set(sess->params,
! 5968: "DataPDUInOrder",
! 5969: sess->DataPDUInOrder ? "Yes" : "No");
! 5970: if (rc < 0) {
! 5971: ISTGT_ERRLOG("iscsi_param_set() failed\n");
! 5972: goto error_return;
! 5973: }
! 5974: rc = istgt_iscsi_param_set(sess->params,
! 5975: "DataSequenceInOrder",
! 5976: sess->DataSequenceInOrder ? "Yes" : "No");
! 5977: if (rc < 0) {
! 5978: ISTGT_ERRLOG("iscsi_param_set() failed\n");
! 5979: goto error_return;
! 5980: }
! 5981: rc = istgt_iscsi_param_set_int(sess->params,
! 5982: "ErrorRecoveryLevel",
! 5983: sess->ErrorRecoveryLevel);
! 5984: if (rc < 0) {
! 5985: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5986: goto error_return;
! 5987: }
! 5988:
! 5989: /* realloc buffer */
! 5990: rc = istgt_iscsi_param_set_int(conn->params,
! 5991: "MaxRecvDataSegmentLength",
! 5992: conn->MaxRecvDataSegmentLength);
! 5993: if (rc < 0) {
! 5994: ISTGT_ERRLOG("iscsi_param_set_int() failed\n");
! 5995: goto error_return;
! 5996: }
! 5997: if (conn->MaxRecvDataSegmentLength != conn->recvbufsize) {
! 5998: xfree(conn->recvbuf);
! 5999: xfree(conn->sendbuf);
! 6000: if (conn->MaxRecvDataSegmentLength < 8192) {
! 6001: conn->recvbufsize = 8192;
! 6002: conn->sendbufsize = 8192;
! 6003: } else {
! 6004: conn->recvbufsize = conn->MaxRecvDataSegmentLength;
! 6005: conn->sendbufsize = conn->MaxRecvDataSegmentLength;
! 6006: }
! 6007: conn->recvbuf = xmalloc(conn->recvbufsize);
! 6008: conn->sendbuf = xmalloc(conn->sendbufsize);
! 6009: }
! 6010:
! 6011: /* sess for first connection of session */
! 6012: conn->sess = sess;
! 6013: return 0;
! 6014: }
! 6015:
! 6016: static int
! 6017: istgt_append_sess(CONN_Ptr conn, uint64_t isid, uint16_t tsih, uint16_t cid)
! 6018: {
! 6019: SESS_Ptr sess;
! 6020: int rc;
! 6021: int i;
! 6022:
! 6023: ISTGT_TRACELOG(ISTGT_TRACE_ISCSI,
! 6024: "append session: isid=%"PRIx64", tsih=%u, cid=%u\n",
! 6025: isid, tsih, cid);
! 6026:
! 6027: sess = NULL;
! 6028: rc = -1;
! 6029: MTX_LOCK(&g_conns_mutex);
! 6030: for (i = 0; i < g_nconns; i++) {
! 6031: if (g_conns[i] == NULL || g_conns[i]->sess == NULL)
! 6032: continue;
! 6033: sess = g_conns[i]->sess;
! 6034: MTX_LOCK(&sess->mutex);
! 6035: if (conn->portal.tag == sess->tag
! 6036: && strcasecmp(conn->initiator_port, sess->initiator_port) == 0
! 6037: && strcasecmp(conn->target_name, sess->target_name) == 0
! 6038: && (isid == sess->isid && tsih == sess->tsih)) {
! 6039: /* match tag and initiator port and target */
! 6040: rc = 0;
! 6041: break;
! 6042: }
! 6043: MTX_UNLOCK(&sess->mutex);
! 6044: }
! 6045: if (rc < 0) {
! 6046: /* no match */
! 6047: MTX_UNLOCK(&g_conns_mutex);
! 6048: ISTGT_ERRLOG("no MCS session for isid=%"PRIx64", tsih=%d, cid=%d\n",
! 6049: isid, tsih, cid);
! 6050: return -1;
! 6051: }
! 6052: /* sess is LOCK by loop */
! 6053: if (sess->connections >= sess->max_conns
! 6054: || sess->connections >= sess->MaxConnections) {
! 6055: /* no slot for connection */
! 6056: MTX_UNLOCK(&sess->mutex);
! 6057: MTX_UNLOCK(&g_conns_mutex);
! 6058: ISTGT_ERRLOG("too many connections for isid=%"PRIx64
! 6059: ", tsih=%d, cid=%d\n",
! 6060: isid, tsih, cid);
! 6061: return -1;
! 6062: }
! 6063: printf("Connections(tsih %d): %d\n", sess->tsih, sess->connections);
! 6064: conn->sess = sess;
! 6065: sess->conns[sess->connections] = conn;
! 6066: sess->connections++;
! 6067: MTX_UNLOCK(&sess->mutex);
! 6068: MTX_UNLOCK(&g_conns_mutex);
! 6069:
! 6070: return 0;
! 6071: }
! 6072:
! 6073: static void
! 6074: istgt_free_sess(SESS_Ptr sess)
! 6075: {
! 6076: if (sess == NULL)
! 6077: return;
! 6078: (void) pthread_mutex_destroy(&sess->mutex);
! 6079: (void) pthread_cond_destroy(&sess->mcs_cond);
! 6080: istgt_iscsi_param_free(sess->params);
! 6081: xfree(sess->initiator_port);
! 6082: xfree(sess->target_name);
! 6083: xfree(sess->conns);
! 6084: xfree(sess);
! 6085: }
! 6086:
! 6087: static void
! 6088: istgt_free_conn(CONN_Ptr conn)
! 6089: {
! 6090: if (conn == NULL)
! 6091: return;
! 6092: if (conn->task_pipe[0] != -1)
! 6093: close(conn->task_pipe[0]);
! 6094: if (conn->task_pipe[1] != -1)
! 6095: close(conn->task_pipe[1]);
! 6096: (void) pthread_mutex_destroy(&conn->task_queue_mutex);
! 6097: (void) pthread_mutex_destroy(&conn->result_queue_mutex);
! 6098: (void) pthread_cond_destroy(&conn->result_queue_cond);
! 6099: (void) pthread_mutex_destroy(&conn->wpdu_mutex);
! 6100: (void) pthread_cond_destroy(&conn->wpdu_cond);
! 6101: (void) pthread_mutex_destroy(&conn->r2t_mutex);
! 6102: (void) pthread_mutex_destroy(&conn->sender_mutex);
! 6103: (void) pthread_cond_destroy(&conn->sender_cond);
! 6104: istgt_iscsi_param_free(conn->params);
! 6105: istgt_queue_destroy(&conn->pending_pdus);
! 6106: istgt_queue_destroy(&conn->task_queue);
! 6107: istgt_queue_destroy(&conn->result_queue);
! 6108: xfree(conn->r2t_tasks);
! 6109: xfree(conn->portal.label);
! 6110: xfree(conn->portal.host);
! 6111: xfree(conn->portal.port);
! 6112: xfree(conn->auth.user);
! 6113: xfree(conn->auth.secret);
! 6114: xfree(conn->auth.muser);
! 6115: xfree(conn->auth.msecret);
! 6116: xfree(conn->shortpdu);
! 6117: xfree(conn->iobuf);
! 6118: xfree(conn->snsbuf);
! 6119: xfree(conn->recvbuf);
! 6120: xfree(conn->sendbuf);
! 6121: xfree(conn->workbuf);
! 6122: xfree(conn);
! 6123: }
! 6124:
! 6125: static void
! 6126: istgt_remove_conn(CONN_Ptr conn)
! 6127: {
! 6128: SESS_Ptr sess;
! 6129: int idx;
! 6130: int i, j;
! 6131:
! 6132: idx = -1;
! 6133: sess = conn->sess;
! 6134: conn->sess = NULL;
! 6135: if (sess == NULL) {
! 6136: istgt_free_conn(conn);
! 6137: return;
! 6138: }
! 6139:
! 6140: MTX_LOCK(&sess->mutex);
! 6141: for (i = 0; i < sess->connections; i++) {
! 6142: if (sess->conns[i] == conn) {
! 6143: idx = i;
! 6144: break;
! 6145: }
! 6146: }
! 6147: if (sess->connections < 1) {
! 6148: ISTGT_ERRLOG("zero connection\n");
! 6149: sess->connections = 0;
! 6150: } else {
! 6151: if (idx < 0) {
! 6152: ISTGT_ERRLOG("remove conn not found\n");
! 6153: } else {
! 6154: for (j = idx; j < sess->connections - 1; j++) {
! 6155: sess->conns[j] = sess->conns[j + 1];
! 6156: }
! 6157: sess->conns[sess->connections - 1] = NULL;
! 6158: }
! 6159: sess->connections--;
! 6160: }
! 6161: printf("Connections(tsih %d): %d\n", sess->tsih, sess->connections);
! 6162: if (sess->connections == 1) {
! 6163: /* cleanup for multiple connecsions */
! 6164: MTX_UNLOCK(&sess->mutex);
! 6165: } else if (sess->connections == 0) {
! 6166: /* cleanup last connection */
! 6167: MTX_UNLOCK(&sess->mutex);
! 6168: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "cleanup last conn free tsih\n");
! 6169: istgt_lu_free_tsih(sess->lu, sess->tsih, conn->initiator_port);
! 6170: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "cleanup last conn free sess\n");
! 6171: istgt_free_sess(sess);
! 6172: } else {
! 6173: MTX_UNLOCK(&sess->mutex);
! 6174: }
! 6175: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "cleanup free conn\n");
! 6176: istgt_free_conn(conn);
! 6177: }
! 6178:
! 6179: static int
! 6180: istgt_iscsi_drop_all_conns(CONN_Ptr conn)
! 6181: {
! 6182: CONN_Ptr xconn;
! 6183: int max_conns;
! 6184: int num;
! 6185: int rc;
! 6186: int i;
! 6187:
! 6188: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_iscsi_drop_all_conns\n");
! 6189:
! 6190: printf("drop all connections %s by %s\n",
! 6191: conn->target_name, conn->initiator_name);
! 6192:
! 6193: MTX_LOCK(&conn->istgt->mutex);
! 6194: max_conns = conn->istgt->MaxConnections;
! 6195: MTX_UNLOCK(&conn->istgt->mutex);
! 6196: num = 0;
! 6197: MTX_LOCK(&g_conns_mutex);
! 6198: for (i = 0; i < g_nconns; i++) {
! 6199: xconn = g_conns[i];
! 6200: if (xconn == NULL)
! 6201: continue;
! 6202: if (xconn == conn)
! 6203: continue;
! 6204: if (strcasecmp(conn->initiator_name, xconn->initiator_name) != 0) {
! 6205: continue;
! 6206: }
! 6207: if (strcasecmp(conn->target_name, xconn->target_name) == 0) {
! 6208: if (xconn->sess != NULL) {
! 6209: printf("exiting conn by %s(%s), TSIH=%u, CID=%u\n",
! 6210: xconn->initiator_name,
! 6211: xconn->initiator_addr,
! 6212: xconn->sess->tsih, xconn->cid);
! 6213: } else {
! 6214: printf("exiting conn by %s(%s), TSIH=xx, CID=%u\n",
! 6215: xconn->initiator_name,
! 6216: xconn->initiator_addr,
! 6217: xconn->cid);
! 6218: }
! 6219: xconn->state = CONN_STATE_EXITING;
! 6220: num++;
! 6221: }
! 6222: }
! 6223: istgt_yield();
! 6224: sleep(1);
! 6225: if (num > max_conns + 1) {
! 6226: printf("try pthread_cancel\n");
! 6227: for (i = 0; i < g_nconns; i++) {
! 6228: xconn = g_conns[i];
! 6229: if (xconn == NULL)
! 6230: continue;
! 6231: if (xconn == conn)
! 6232: continue;
! 6233: if (strcasecmp(conn->initiator_port, xconn->initiator_port) != 0) {
! 6234: continue;
! 6235: }
! 6236: if (strcasecmp(conn->target_name, xconn->target_name) == 0) {
! 6237: if (xconn->sess != NULL) {
! 6238: printf("exiting conn by %s(%s), TSIH=%u, CID=%u\n",
! 6239: xconn->initiator_port,
! 6240: xconn->initiator_addr,
! 6241: xconn->sess->tsih, xconn->cid);
! 6242: } else {
! 6243: printf("exiting conn by %s(%s), TSIH=xx, CID=%u\n",
! 6244: xconn->initiator_port,
! 6245: xconn->initiator_addr,
! 6246: xconn->cid);
! 6247: }
! 6248: rc = pthread_cancel(xconn->thread);
! 6249: if (rc != 0) {
! 6250: ISTGT_ERRLOG("pthread_cancel() failed rc=%d\n", rc);
! 6251: }
! 6252: }
! 6253: }
! 6254: }
! 6255: MTX_UNLOCK(&g_conns_mutex);
! 6256:
! 6257: if (num != 0) {
! 6258: printf("exiting %d conns\n", num);
! 6259: }
! 6260: return 0;
! 6261: }
! 6262:
! 6263: static int
! 6264: istgt_iscsi_drop_old_conns(CONN_Ptr conn)
! 6265: {
! 6266: CONN_Ptr xconn;
! 6267: int max_conns;
! 6268: int num;
! 6269: int rc;
! 6270: int i;
! 6271:
! 6272: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_iscsi_drop_old_conns\n");
! 6273:
! 6274: printf("drop old connections %s by %s\n",
! 6275: conn->target_name, conn->initiator_port);
! 6276:
! 6277: MTX_LOCK(&conn->istgt->mutex);
! 6278: max_conns = conn->istgt->MaxConnections;
! 6279: MTX_UNLOCK(&conn->istgt->mutex);
! 6280: num = 0;
! 6281: MTX_LOCK(&g_conns_mutex);
! 6282: for (i = 0; i < g_nconns; i++) {
! 6283: xconn = g_conns[i];
! 6284: if (xconn == NULL)
! 6285: continue;
! 6286: if (xconn == conn)
! 6287: continue;
! 6288: if (strcasecmp(conn->initiator_port, xconn->initiator_port) != 0) {
! 6289: continue;
! 6290: }
! 6291: if (strcasecmp(conn->target_name, xconn->target_name) == 0) {
! 6292: if (xconn->sess != NULL) {
! 6293: printf("exiting conn by %s(%s), TSIH=%u, CID=%u\n",
! 6294: xconn->initiator_port,
! 6295: xconn->initiator_addr,
! 6296: xconn->sess->tsih, xconn->cid);
! 6297: } else {
! 6298: printf("exiting conn by %s(%s), TSIH=xx, CID=%u\n",
! 6299: xconn->initiator_port,
! 6300: xconn->initiator_addr,
! 6301: xconn->cid);
! 6302: }
! 6303: xconn->state = CONN_STATE_EXITING;
! 6304: num++;
! 6305: }
! 6306: }
! 6307: istgt_yield();
! 6308: sleep(1);
! 6309: if (num > max_conns + 1) {
! 6310: printf("try pthread_cancel\n");
! 6311: for (i = 0; i < g_nconns; i++) {
! 6312: xconn = g_conns[i];
! 6313: if (xconn == NULL)
! 6314: continue;
! 6315: if (xconn == conn)
! 6316: continue;
! 6317: if (strcasecmp(conn->initiator_port, xconn->initiator_port) != 0) {
! 6318: continue;
! 6319: }
! 6320: if (strcasecmp(conn->target_name, xconn->target_name) == 0) {
! 6321: if (xconn->sess != NULL) {
! 6322: printf("exiting conn by %s(%s), TSIH=%u, CID=%u\n",
! 6323: xconn->initiator_port,
! 6324: xconn->initiator_addr,
! 6325: xconn->sess->tsih, xconn->cid);
! 6326: } else {
! 6327: printf("exiting conn by %s(%s), TSIH=xx, CID=%u\n",
! 6328: xconn->initiator_port,
! 6329: xconn->initiator_addr,
! 6330: xconn->cid);
! 6331: }
! 6332: rc = pthread_cancel(xconn->thread);
! 6333: if (rc != 0) {
! 6334: ISTGT_ERRLOG("pthread_cancel() failed rc=%d\n", rc);
! 6335: }
! 6336: }
! 6337: }
! 6338: }
! 6339: MTX_UNLOCK(&g_conns_mutex);
! 6340:
! 6341: if (num != 0) {
! 6342: printf("exiting %d conns\n", num);
! 6343: }
! 6344: return 0;
! 6345: }
! 6346:
! 6347: void
! 6348: istgt_lock_gconns(void)
! 6349: {
! 6350: MTX_LOCK(&g_conns_mutex);
! 6351: }
! 6352:
! 6353: void
! 6354: istgt_unlock_gconns(void)
! 6355: {
! 6356: MTX_UNLOCK(&g_conns_mutex);
! 6357: }
! 6358:
! 6359: int
! 6360: istgt_get_gnconns(void)
! 6361: {
! 6362: return g_nconns;
! 6363: }
! 6364:
! 6365: CONN_Ptr
! 6366: istgt_get_gconn(int idx)
! 6367: {
! 6368: if (idx >= g_nconns)
! 6369: return NULL;
! 6370: return g_conns[idx];
! 6371: }
! 6372:
! 6373: int
! 6374: istgt_get_active_conns(void)
! 6375: {
! 6376: CONN_Ptr conn;
! 6377: int num = 0;
! 6378: int i;
! 6379:
! 6380: MTX_LOCK(&g_conns_mutex);
! 6381: for (i = 0; i < g_nconns; i++) {
! 6382: conn = g_conns[i];
! 6383: if (conn == NULL)
! 6384: continue;
! 6385: num++;
! 6386: }
! 6387: MTX_UNLOCK(&g_conns_mutex);
! 6388: return num;
! 6389: }
! 6390:
! 6391: CONN_Ptr
! 6392: istgt_find_conn(const char *initiator_port, const char *target_name, uint16_t tsih)
! 6393: {
! 6394: CONN_Ptr conn;
! 6395: SESS_Ptr sess;
! 6396: int rc;
! 6397: int i;
! 6398:
! 6399: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 6400: "initiator_port=%s, target=%s, TSIH=%u",
! 6401: initiator_port, target_name, tsih);
! 6402: sess = NULL;
! 6403: rc = -1;
! 6404: //MTX_LOCK(&g_conns_mutex);
! 6405: for (i = 0; i < g_nconns; i++) {
! 6406: conn = g_conns[i];
! 6407: if (conn == NULL || conn->sess == NULL)
! 6408: continue;
! 6409: sess = conn->sess;
! 6410: MTX_LOCK(&sess->mutex);
! 6411: if (strcasecmp(initiator_port, sess->initiator_port) == 0
! 6412: && strcasecmp(target_name, sess->target_name) == 0
! 6413: && (tsih == sess->tsih)) {
! 6414: /* match initiator port and target */
! 6415: rc = 0;
! 6416: break;
! 6417: }
! 6418: MTX_UNLOCK(&sess->mutex);
! 6419: }
! 6420: if (rc < 0) {
! 6421: //MTX_UNLOCK(&g_conns_mutex);
! 6422: return NULL;
! 6423: }
! 6424: MTX_UNLOCK(&sess->mutex);
! 6425: //MTX_UNLOCK(&g_conns_mutex);
! 6426: return conn;
! 6427: }
! 6428:
! 6429: int
! 6430: istgt_iscsi_init(ISTGT_Ptr istgt)
! 6431: {
! 6432: CF_SECTION *sp;
! 6433: int rc;
! 6434: int i;
! 6435:
! 6436: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_iscsi_init\n");
! 6437: sp = istgt_find_cf_section(istgt->config, "Global");
! 6438: if (sp == NULL) {
! 6439: ISTGT_ERRLOG("find_cf_section failed()\n");
! 6440: return -1;
! 6441: }
! 6442:
! 6443: rc = pthread_mutex_init(&g_conns_mutex, NULL);
! 6444: if (rc != 0) {
! 6445: ISTGT_ERRLOG("mutex_init() failed\n");
! 6446: return -1;
! 6447: }
! 6448: rc = pthread_mutex_init(&g_last_tsih_mutex, NULL);
! 6449: if (rc != 0) {
! 6450: ISTGT_ERRLOG("mutex_init() failed\n");
! 6451: return -1;
! 6452: }
! 6453:
! 6454: g_nconns = MAX_LOGICAL_UNIT * istgt->MaxSessions * istgt->MaxConnections;
! 6455: g_nconns += MAX_LOGICAL_UNIT * istgt->MaxConnections;
! 6456: g_conns = xmalloc(sizeof *g_conns * g_nconns);
! 6457: for (i = 0; i < g_nconns; i++) {
! 6458: g_conns[i] = NULL;
! 6459: }
! 6460: g_last_tsih = 0;
! 6461:
! 6462: return 0;
! 6463: }
! 6464:
! 6465: int
! 6466: istgt_iscsi_shutdown(ISTGT_Ptr istgt)
! 6467: {
! 6468: CONN_Ptr conn;
! 6469: int retry = 10;
! 6470: int num;
! 6471: int rc;
! 6472: int i;
! 6473:
! 6474: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG, "istgt_iscsi_shutdown\n");
! 6475:
! 6476: num = 0;
! 6477: MTX_LOCK(&g_conns_mutex);
! 6478: for (i = 0; i < g_nconns; i++) {
! 6479: conn = g_conns[i];
! 6480: if (conn == NULL)
! 6481: continue;
! 6482: conn->state = CONN_STATE_EXITING;
! 6483: num++;
! 6484: }
! 6485: MTX_UNLOCK(&g_conns_mutex);
! 6486:
! 6487: if (num != 0) {
! 6488: /* check threads */
! 6489: while (retry > 0) {
! 6490: ISTGT_TRACELOG(ISTGT_TRACE_DEBUG,
! 6491: "check thread retry=%d\n",
! 6492: retry);
! 6493: sleep(1);
! 6494: num = 0;
! 6495: MTX_LOCK(&g_conns_mutex);
! 6496: for (i = 0; i < g_nconns; i++) {
! 6497: conn = g_conns[i];
! 6498: if (conn == NULL)
! 6499: continue;
! 6500: num++;
! 6501: }
! 6502: MTX_UNLOCK(&g_conns_mutex);
! 6503: if (num == 0)
! 6504: break;
! 6505: retry--;
! 6506: }
! 6507: }
! 6508:
! 6509: rc = pthread_mutex_destroy(&g_last_tsih_mutex);
! 6510: if (rc != 0) {
! 6511: ISTGT_ERRLOG("mutex_destroy() failed\n");
! 6512: return -1;
! 6513: }
! 6514: rc = pthread_mutex_destroy(&g_conns_mutex);
! 6515: if (rc != 0) {
! 6516: ISTGT_ERRLOG("mutex_destroy() failed\n");
! 6517: return -1;
! 6518: }
! 6519:
! 6520: return 0;
! 6521: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to istgt_iscsi.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / istgt / src