Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/dev/iscsi/iscsi_send.c

1669 lines
40 KiB
C
Raw Blame History

/* $NetBSD: iscsi_send.c,v 1.8 2012/12/29 11:05:30 mlelstv Exp $ */
/*-
* Copyright (c) 2004,2005,2006,2011 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Wasabi Systems, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include "iscsi_globals.h"
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
/*#define LUN_1 1 */
/*****************************************************************************/
/*
* my_soo_write:
* Replacement for soo_write with flag handling.
*
* Parameter:
* conn The connection
* u The uio descriptor
*
* Returns: 0 on success, else EIO.
*/
STATIC int
my_soo_write(connection_t *conn, struct uio *u)
{
struct socket *so = (struct socket *) conn->sock->f_data;
size_t resid = u->uio_resid;
int ret;
assert(resid != 0);
#if (__NetBSD_Version__ >= 300000000)
ret = sosend(so, NULL, u, NULL, NULL, 0, conn->threadobj);
#else
ret = sosend(so, NULL, u, NULL, NULL, 0);
#endif
DEB(99, ("soo_write done: len = %zu\n", u->uio_resid));
if (ret != 0 || u->uio_resid) {
DEBC(conn, 0, ("Write failed sock %p (ret: %d, req: %zu, resid: %zu)\n",
conn->sock, ret, resid, u->uio_resid));
handle_connection_error(conn, ISCSI_STATUS_SOCKET_ERROR, NO_LOGOUT);
return EIO;
}
return 0;
}
/*****************************************************************************/
/*
* assign_connection:
* This function returns the connection to use for the next transaction.
*
* Parameter: The session
*
* Returns: The connection
*/
connection_t *
assign_connection(session_t *session, bool waitok)
{
connection_t *conn, *next;
do {
if ((conn = session->mru_connection) == NULL) {
return NULL;
}
next = conn;
do {
next = TAILQ_NEXT(next, connections);
if (next == NULL) {
next = TAILQ_FIRST(&session->conn_list);
}
} while (next != NULL && next != conn &&
next->state != ST_FULL_FEATURE);
if (next->state != ST_FULL_FEATURE) {
if (waitok) {
tsleep(session, PRIBIO, "iscsi_assign_connection", 0);
next = TAILQ_FIRST(&session->conn_list);
} else {
return NULL;
}
} else {
session->mru_connection = next;
}
} while (next != NULL && next->state != ST_FULL_FEATURE);
return next;
}
/*
* reassign_tasks:
* Reassign pending commands to one of the still existing connections
* of a session.
*
* Parameter:
* oldconn The terminating connection
*/
STATIC void
reassign_tasks(connection_t *oldconn)
{
session_t *sess = oldconn->session;
connection_t *conn;
ccb_t *ccb;
pdu_t *pdu = NULL;
pdu_t *opdu;
int no_tm = 1;
int rc = 1;
int s;
if ((conn = assign_connection(sess, FALSE)) == NULL) {
DEB(1, ("Reassign_tasks of Session %d, connection %d failed, "
"no active connection\n",
sess->id, oldconn->id));
/* XXX here we need to abort the waiting CCBs */
return;
}
if (sess->ErrorRecoveryLevel >= 2) {
if (oldconn->loggedout == NOT_LOGGED_OUT) {
oldconn->loggedout = LOGOUT_SENT;
no_tm = send_logout(conn, oldconn, RECOVER_CONNECTION, TRUE);
oldconn->loggedout = (rc) ? LOGOUT_FAILED : LOGOUT_SUCCESS;
if (!oldconn->Time2Retain) {
DEBC(conn, 1, ("Time2Retain is zero, setting no_tm\n"));
no_tm = 1;
}
} else if (oldconn->loggedout == LOGOUT_SUCCESS) {
no_tm = 0;
}
if (!no_tm && oldconn->Time2Wait) {
DEBC(conn, 1, ("Time2Wait=%d, hz=%d, waiting...\n",
oldconn->Time2Wait, hz));
tsleep(&no_tm, PRIBIO, "Time2Wait", oldconn->Time2Wait * hz);
}
}
DEBC(conn, 1, ("Reassign_tasks: Session %d, conn %d -> conn %d, no_tm=%d\n",
sess->id, oldconn->id, conn->id, no_tm));
/* XXX reassign waiting CCBs to new connection */
while ((ccb = TAILQ_FIRST(&oldconn->ccbs_waiting)) != NULL) {
/* Copy PDU contents (PDUs are bound to connection) */
if ((pdu = get_pdu(conn, TRUE)) == NULL) {
break;
}
/* adjust CCB and clone PDU for new connection */
TAILQ_REMOVE(&oldconn->ccbs_waiting, ccb, chain);
opdu = ccb->pdu_waiting;
*pdu = *opdu;
/* restore overwritten back ptr */
pdu->connection = conn;
/* fixup saved UIO and IOVEC (regular one will be overwritten anyway) */
pdu->save_uio.uio_iov = pdu->io_vec;
pdu->save_iovec [0].iov_base = &pdu->pdu;
if (conn->DataDigest && pdu->save_uio.uio_iovcnt > 1) {
if (pdu->save_iovec [2].iov_base == NULL) {
pdu->save_iovec [2].iov_base = &pdu->data_digest;
pdu->save_uio.uio_iovcnt = 3;
} else {
pdu->save_iovec [3].iov_base = &pdu->data_digest;
pdu->save_uio.uio_iovcnt = 4;
}
}
pdu->save_iovec [0].iov_len =
(conn->HeaderDigest) ? BHS_SIZE + 4 : BHS_SIZE;
/* link new PDU into old CCB */
ccb->pdu_waiting = pdu;
/* link new CCB into new connection */
ccb->connection = conn;
/* reset timeouts */
ccb->num_timeouts = 0;
/* fixup reference counts */
oldconn->usecount--;
conn->usecount++;
DEBC(conn, 1, ("CCB %p: Copied PDU %p to %p\n",
ccb, opdu, pdu));
/* kill temp pointer that is now referenced by the new PDU */
opdu->temp_data = NULL;
/* and free the old PDU */
free_pdu(opdu);
/* put ready CCB into waiting list of new connection */
s = splbio();
suspend_ccb(ccb, TRUE);
splx(s);
}
if (pdu == NULL) {
DEBC(conn, 1, ("Error while copying PDUs in reassign_tasks!\n"));
/* give up recovering, the other connection is screwed up as well... */
while ((ccb = TAILQ_FIRST(&oldconn->ccbs_waiting)) != NULL) {
wake_ccb(ccb, oldconn->terminating);
}
/* XXX some CCBs might have been moved to new connection, but how is the
* new connection handled or killed ? */
return;
}
TAILQ_FOREACH(ccb, &conn->ccbs_waiting, chain) {
if (!no_tm) {
rc = send_task_management(conn, ccb, NULL, TASK_REASSIGN);
}
/* if we get an error on reassign, restart the original request */
if (no_tm || rc) {
if (ccb->CmdSN < sess->ExpCmdSN) {
pdu = ccb->pdu_waiting;
/* update CmdSN */
DEBC(conn, 1, ("Resend Updating CmdSN - old %d, new %d\n",
ccb->CmdSN, sess->CmdSN));
ccb->CmdSN = sess->CmdSN;
if (!(pdu->pdu.Opcode & OP_IMMEDIATE)) {
sess->CmdSN++;
}
pdu->pdu.p.command.CmdSN = htonl(ccb->CmdSN);
}
resend_pdu(ccb);
} else {
SET_CCB_TIMEOUT(conn, ccb, COMMAND_TIMEOUT);
}
DEBC(conn, 1, ("Reassign ccb %p, no_tm=%d, rc=%d\n",
ccb, no_tm, rc));
}
}
/*
* iscsi_send_thread:
* This thread services the send queue, writing the PDUs to the socket.
* It also handles the cleanup when the connection is terminated.
*
* Parameter:
* par The connection this thread services
*/
void
iscsi_send_thread(void *par)
{
connection_t *conn = (connection_t *) par;
session_t *sess;
ccb_t *ccb, *nccb;
pdu_t *pdu;
struct file *fp;
int s;
sess = conn->session;
/* so cleanup thread knows there's someone left */
iscsi_num_send_threads++;
do {
while (!conn->terminating) {
s = splbio();
while (!conn->terminating &&
(pdu = TAILQ_FIRST(&conn->pdus_to_send)) != NULL) {
TAILQ_REMOVE(&conn->pdus_to_send, pdu, send_chain);
pdu->flags &= ~PDUF_INQUEUE;
splx(s);
PERF_PDUSNAPB(pdu);
#ifdef ISCSI_DEBUG
if (!pdu->uio.uio_resid) {
DEBOUT(("uio.resid = 0 in iscsi_send_thread! pdu=%p\n",
pdu));
assert(pdu->uio.uio_resid != 0);
}
#endif
/*DEB (99,("Send thread woke up, pdu = %x)\n", (int)pdu)); */
#ifdef ISCSI_TEST_MODE
if (!test_mode_tx(conn, pdu)) {
if (!(pdu->flags & PDUF_NOUPDATE)) {
#endif
/* update ExpStatSN here to avoid discontinuities */
/* and delays in updating target */
pdu->pdu.p.command.ExpStatSN =
htonl(conn->StatSN_buf.ExpSN);
if (conn->HeaderDigest)
pdu->pdu.HeaderDigest =
gen_digest(&pdu->pdu, BHS_SIZE);
#ifdef ISCSI_TEST_MODE
}
#endif
my_soo_write(conn, &pdu->uio);
#ifdef ISCSI_TEST_MODE
}
#endif
PERF_PDUSNAPE(pdu);
if (pdu->disp <= PDUDISP_FREE) {
free_pdu(pdu);
} else {
pdu->flags &= ~PDUF_BUSY;
}
s = splbio();
}
/*DEB (99,("Send thread done, waiting (conn->terminating = %d)\n", */
/* conn->terminating)); */
if (!conn->terminating) {
tsleep(&conn->pdus_to_send, PRIBIO,
"iscsisend", 0);
}
splx(s);
}
/* ------------------------------------------------------------------------
* Here this thread takes over cleanup of the terminating connection.
* ------------------------------------------------------------------------
*/
callout_stop(&conn->timeout);
conn->idle_timeout_val = CONNECTION_IDLE_TIMEOUT;
fp = conn->sock;
/*
* We shutdown the socket here to force the receive
* thread to wake up
*/
DEBC(conn, 1, ("Closing Socket %p\n", conn->sock));
solock((struct socket *) fp->f_data);
soshutdown((struct socket *) fp->f_data, SHUT_RDWR);
sounlock((struct socket *) fp->f_data);
/* wake up any non-reassignable waiting CCBs */
TAILQ_FOREACH_SAFE(ccb, &conn->ccbs_waiting, chain, nccb) {
if (!(ccb->flags & CCBF_REASSIGN) || ccb->pdu_waiting == NULL) {
DEBC(conn, 1, ("Terminating CCB %p (t=%p)\n",
ccb,&ccb->timeout));
wake_ccb(ccb, conn->terminating);
} else {
callout_stop(&ccb->timeout);
ccb->num_timeouts = 0;
}
}
/* clean out anything left in send queue */
while ((pdu = TAILQ_FIRST(&conn->pdus_to_send)) != NULL) {
TAILQ_REMOVE(&conn->pdus_to_send, pdu, send_chain);
pdu->flags &= ~(PDUF_INQUEUE | PDUF_BUSY);
/* if it's not attached to a waiting CCB, free it */
if (pdu->owner == NULL ||
pdu->owner->pdu_waiting != pdu) {
free_pdu(pdu);
}
}
/* If there's another connection available, transfer pending tasks */
if (sess->active_connections &&
TAILQ_FIRST(&conn->ccbs_waiting) != NULL) {
DEBC(conn, 1, ("Reassign Tasks\n"));
reassign_tasks(conn);
} else if (!conn->destroy && conn->Time2Wait) {
DEBC(conn, 1, ("Time2Wait\n"));
tsleep(&s, PRIBIO, "Time2Wait", conn->Time2Wait * hz);
DEBC(conn, 1, ("Time2Wait\n"));
}
/* notify event handlers of connection shutdown */
DEBC(conn, 1, ("%s\n", (conn->destroy) ? "TERMINATED" : "RECOVER"));
add_event((conn->destroy) ? ISCSI_CONNECTION_TERMINATED
: ISCSI_RECOVER_CONNECTION,
sess->id, conn->id, conn->terminating);
DEBC(conn, 1, ("Waiting for conn_idle\n"));
if (!conn->destroy)
tsleep(conn, PRIBIO, "conn_idle", 30 * hz);
DEBC(conn, 1, ("Waited for conn_idle, destroy = %d\n", conn->destroy));
} while (!conn->destroy);
/* wake up anyone waiting for a PDU */
wakeup(&conn->pdu_pool);
/* wake up any waiting CCBs */
while ((ccb = TAILQ_FIRST(&conn->ccbs_waiting)) != NULL) {
wake_ccb(ccb, conn->terminating);
/* NOTE: wake_ccb will remove the CCB from the queue */
}
s = splbio();
if (conn->in_session) {
conn->in_session = FALSE;
TAILQ_REMOVE(&sess->conn_list, conn, connections);
sess->mru_connection = TAILQ_FIRST(&sess->conn_list);
}
TAILQ_INSERT_TAIL(&iscsi_cleanupc_list, conn, connections);
splx(s);
wakeup(&iscsi_cleanupc_list);
conn->sendproc = NULL;
DEBC(conn, 1, ("Send thread exits\n"));
iscsi_num_send_threads--;
kthread_exit(0);
}
/*
* send_pdu:
* Enqueue a PDU to be sent, and handle its disposition as well as
* the disposition of its associated CCB.
*
* Parameter:
* ccb The associated CCB. May be NULL if cdisp is CCBDISP_NOWAIT
* and pdisp is not PDUDISP_WAIT
* cdisp The CCB's disposition
* pdu The PDU
* pdisp The PDU's disposition
*/
STATIC void
send_pdu(ccb_t *ccb, pdu_t *pdu, ccb_disp_t cdisp, pdu_disp_t pdisp)
{
connection_t *conn = pdu->connection;
ccb_disp_t prev_cdisp = 0;
int s;
if (ccb != NULL) {
prev_cdisp = ccb->disp;
pdu->pdu.InitiatorTaskTag = ccb->ITT;
pdu->owner = ccb;
if (cdisp != CCBDISP_NOWAIT)
ccb->disp = cdisp;
}
pdu->disp = pdisp;
DEBC(conn, 10, ("Send_pdu: ccb=%p, pcd=%d, cdsp=%d, pdu=%p, pdsp=%d\n",
ccb, prev_cdisp, cdisp, pdu, pdisp));
s = splbio();
if (pdisp == PDUDISP_WAIT) {
ccb->pdu_waiting = pdu;
/* save UIO and IOVEC for retransmit */
pdu->save_uio = pdu->uio;
memcpy(pdu->save_iovec, pdu->io_vec, sizeof(pdu->save_iovec));
pdu->flags |= PDUF_BUSY;
}
/* Enqueue for sending */
pdu->flags |= PDUF_INQUEUE;
if (pdu->flags & PDUF_PRIORITY)
TAILQ_INSERT_HEAD(&conn->pdus_to_send, pdu, send_chain);
else
TAILQ_INSERT_TAIL(&conn->pdus_to_send, pdu, send_chain);
wakeup(&conn->pdus_to_send);
if (cdisp != CCBDISP_NOWAIT) {
SET_CCB_TIMEOUT(conn, ccb, COMMAND_TIMEOUT);
if (prev_cdisp <= CCBDISP_NOWAIT)
suspend_ccb(ccb, TRUE);
if (cdisp == CCBDISP_WAIT)
tsleep(ccb, PWAIT, "sendpdu", 0);
}
splx(s);
}
/*
* resend_pdu:
* Re-Enqueue a PDU that has apparently gotten lost.
*
* Parameter:
* ccb The associated CCB.
*/
void
resend_pdu(ccb_t *ccb)
{
connection_t *conn = ccb->connection;
pdu_t *pdu = ccb->pdu_waiting;
int s;
s = splbio ();
if (pdu == NULL || (pdu->flags & PDUF_BUSY)) {
splx (s);
return;
}
pdu->flags |= PDUF_BUSY;
splx (s);
/* restore UIO and IOVEC */
pdu->uio = pdu->save_uio;
memcpy(pdu->io_vec, pdu->save_iovec, sizeof(pdu->io_vec));
DEBC(conn, 8, ("ReSend_pdu ccb=%p, pdu=%p\n", ccb, pdu));
s = splbio ();
/* Enqueue for sending */
pdu->flags |= PDUF_INQUEUE;
if (pdu->flags & PDUF_PRIORITY) {
TAILQ_INSERT_HEAD(&conn->pdus_to_send, pdu, send_chain);
} else {
TAILQ_INSERT_TAIL(&conn->pdus_to_send, pdu, send_chain);
}
SET_CCB_TIMEOUT(conn, ccb, COMMAND_TIMEOUT);
splx (s);
wakeup(&conn->pdus_to_send);
}
/*
* setup_tx_uio:
* Initialize the uio structure for sending, including header,
* data (if present), padding, and Data Digest.
* Header Digest is generated in send thread.
*
* Parameter:
* pdu The PDU
* dsl The Data Segment Length
* data The data pointer
* read TRUE if this is a read operation
*/
STATIC void
setup_tx_uio(pdu_t *pdu, uint32_t dsl, void *data, bool read)
{
static uint8_t pad_bytes[4] = { 0 };
struct uio *uio;
int i, pad, hlen;
connection_t *conn = pdu->connection;
DEB(99, ("SetupTxUio: dlen = %d, dptr: %p, read: %d\n",
dsl, data, read));
if (!read && dsl) {
hton3(dsl, pdu->pdu.DataSegmentLength);
}
hlen = (conn->HeaderDigest) ? BHS_SIZE + 4 : BHS_SIZE;
pdu->io_vec[0].iov_base = &pdu->pdu;
pdu->io_vec[0].iov_len = hlen;
uio = &pdu->uio;
uio->uio_iov = pdu->io_vec;
uio->uio_iovcnt = 1;
uio->uio_rw = UIO_WRITE;
uio->uio_resid = hlen;
UIO_SETUP_SYSSPACE(uio);
if (!read && dsl) {
uio->uio_iovcnt++;
pdu->io_vec[1].iov_base = data;
pdu->io_vec[1].iov_len = dsl;
uio->uio_resid += dsl;
/* Pad to next multiple of 4 */
pad = uio->uio_resid & 0x03;
if (pad) {
i = uio->uio_iovcnt++;
pad = 4 - pad;
pdu->io_vec[i].iov_base = pad_bytes;
pdu->io_vec[i].iov_len = pad;
uio->uio_resid += pad;
}
if (conn->DataDigest) {
pdu->data_digest = gen_digest_2(data, dsl, pad_bytes, pad);
i = uio->uio_iovcnt++;
pdu->io_vec[i].iov_base = &pdu->data_digest;
pdu->io_vec[i].iov_len = 4;
uio->uio_resid += 4;
}
}
}
/*
* init_login_pdu:
* Initialize the login PDU.
*
* Parameter:
* conn The connection
* pdu The PDU
*/
STATIC void
init_login_pdu(connection_t *conn, pdu_t *ppdu, bool next)
{
pdu_header_t *pdu = &ppdu->pdu;
login_isid_t *isid = (login_isid_t *) & pdu->LUN;
uint8_t c_phase;
pdu->Opcode = IOP_Login_Request | OP_IMMEDIATE;
if (next) {
c_phase = (pdu->Flags >> CSG_SHIFT) & SG_MASK;
pdu->Flags = FLAG_TRANSIT | (c_phase << CSG_SHIFT) |
NEXT_PHASE(c_phase);
}
memcpy(isid, &iscsi_InitiatorISID, 6);
isid->TSIH = conn->session->TSIH;
pdu->p.login_req.CID = htons(conn->id);
pdu->p.login_req.CmdSN = htonl(conn->session->CmdSN);
}
/*
* negotiate_login:
* Control login negotiation.
*
* Parameter:
* conn The connection
* rx_pdu The received login response PDU
* tx_ccb The originally sent login CCB
*/
void
negotiate_login(connection_t *conn, pdu_t *rx_pdu, ccb_t *tx_ccb)
{
int rc;
bool next = TRUE;
pdu_t *tx_pdu;
uint8_t c_phase;
if (rx_pdu->pdu.Flags & FLAG_TRANSIT)
c_phase = rx_pdu->pdu.Flags & SG_MASK;
else
c_phase = (rx_pdu->pdu.Flags >> CSG_SHIFT) & SG_MASK;
DEB(99, ("NegotiateLogin: Flags=%x Phase=%x\n",
rx_pdu->pdu.Flags, c_phase));
if (c_phase == SG_FULL_FEATURE_PHASE) {
session_t *sess = conn->session;
if (!sess->TSIH)
sess->TSIH = ((login_isid_t *) &rx_pdu->pdu.LUN)->TSIH;
if (rx_pdu->temp_data != NULL)
assemble_negotiation_parameters(conn, tx_ccb, rx_pdu, NULL);
/* negotiated values are now valid */
set_negotiated_parameters(tx_ccb);
DEBC(conn, 5, ("Login Successful!\n"));
wake_ccb(tx_ccb, ISCSI_STATUS_SUCCESS);
return;
}
tx_pdu = get_pdu(conn, TRUE);
if (tx_pdu == NULL)
return;
tx_pdu->pdu.Flags = c_phase << CSG_SHIFT;
switch (c_phase) {
case SG_SECURITY_NEGOTIATION:
rc = assemble_security_parameters(conn, tx_ccb, rx_pdu, tx_pdu);
if (rc < 0)
next = FALSE;
break;
case SG_LOGIN_OPERATIONAL_NEGOTIATION:
rc = assemble_negotiation_parameters(conn, tx_ccb, rx_pdu, tx_pdu);
break;
default:
DEBOUT(("Invalid phase %x in negotiate_login\n", c_phase));
rc = ISCSI_STATUS_TARGET_ERROR;
break;
}
if (rc > 0) {
wake_ccb(tx_ccb, rc);
free_pdu(tx_pdu);
} else {
init_login_pdu(conn, tx_pdu, next);
setup_tx_uio(tx_pdu, tx_pdu->temp_data_len, tx_pdu->temp_data, FALSE);
send_pdu(tx_ccb, tx_pdu, CCBDISP_NOWAIT, PDUDISP_FREE);
}
}
/*
* init_text_pdu:
* Initialize the text PDU.
*
* Parameter:
* conn The connection
* ppdu The transmit PDU
* rx_pdu The received PDU if this is an unsolicited negotiation
*/
STATIC void
init_text_pdu(connection_t *conn, pdu_t *ppdu, pdu_t *rx_pdu)
{
pdu_header_t *pdu = &ppdu->pdu;
pdu->Opcode = IOP_Text_Request | OP_IMMEDIATE;
pdu->Flags = FLAG_FINAL;
if (rx_pdu != NULL) {
pdu->p.text_req.TargetTransferTag =
rx_pdu->pdu.p.text_rsp.TargetTransferTag;
pdu->LUN = rx_pdu->pdu.LUN;
} else
pdu->p.text_req.TargetTransferTag = 0xffffffff;
pdu->p.text_req.CmdSN = htonl(conn->session->CmdSN);
}
/*
* acknowledge_text:
* Acknowledge a continued login or text response.
*
* Parameter:
* conn The connection
* rx_pdu The received login/text response PDU
* tx_ccb The originally sent login/text request CCB
*/
void
acknowledge_text(connection_t *conn, pdu_t *rx_pdu, ccb_t *tx_ccb)
{
pdu_t *tx_pdu;
tx_pdu = get_pdu(conn, TRUE);
if (tx_pdu == NULL)
return;
if (rx_pdu != NULL &&
(rx_pdu->pdu.Opcode & OPCODE_MASK) == IOP_Login_Request)
init_login_pdu(conn, tx_pdu, FALSE);
else
init_text_pdu(conn, tx_pdu, rx_pdu);
setup_tx_uio(tx_pdu, 0, NULL, FALSE);
send_pdu(tx_ccb, tx_pdu, CCBDISP_NOWAIT, PDUDISP_FREE);
}
/*
* start_text_negotiation:
* Handle target request to negotiate (via asynch event)
*
* Parameter:
* conn The connection
*/
void
start_text_negotiation(connection_t *conn)
{
pdu_t *pdu;
ccb_t *ccb;
ccb = get_ccb(conn, TRUE);
if (ccb == NULL)
return;
pdu = get_pdu(conn, TRUE);
if (pdu == NULL) {
free_ccb(ccb);
return;
}
if (init_text_parameters(conn, ccb)) {
free_ccb(ccb);
free_pdu(pdu);
return;
}
init_text_pdu(conn, pdu, NULL);
setup_tx_uio(pdu, 0, NULL, FALSE);
send_pdu(ccb, pdu, CCBDISP_FREE, PDUDISP_WAIT);
}
/*
* negotiate_text:
* Handle received text negotiation.
*
* Parameter:
* conn The connection
* rx_pdu The received text response PDU
* tx_ccb The original CCB
*/
void
negotiate_text(connection_t *conn, pdu_t *rx_pdu, ccb_t *tx_ccb)
{
int rc;
pdu_t *tx_pdu;
if (tx_ccb->flags & CCBF_SENDTARGET) {
if (!(rx_pdu->pdu.Flags & FLAG_FINAL)) {
handle_connection_error(conn, ISCSI_STATUS_PROTOCOL_ERROR,
LOGOUT_CONNECTION);
return;
}
/* transfer ownership of text to CCB */
tx_ccb->text_data = rx_pdu->temp_data;
tx_ccb->text_len = rx_pdu->temp_data_len;
rx_pdu->temp_data = NULL;
wake_ccb(tx_ccb, ISCSI_STATUS_SUCCESS);
} else {
if (!(rx_pdu->pdu.Flags & FLAG_FINAL))
tx_pdu = get_pdu(conn, TRUE);
else
tx_pdu = NULL;
rc = assemble_negotiation_parameters(conn, tx_ccb, rx_pdu, tx_pdu);
if (rc) {
if (tx_pdu != NULL)
free_pdu(tx_pdu);
handle_connection_error(conn, rc, LOGOUT_CONNECTION);
} else if (tx_pdu != NULL) {
init_text_pdu(conn, tx_pdu, rx_pdu);
setup_tx_uio(tx_pdu, tx_pdu->temp_data_len, tx_pdu->temp_data,
FALSE);
send_pdu(tx_ccb, tx_pdu, CCBDISP_NOWAIT, PDUDISP_FREE);
} else {
set_negotiated_parameters(tx_ccb);
wake_ccb(tx_ccb, ISCSI_STATUS_SUCCESS);
}
}
}
/*
* send_send_targets:
* Send out a SendTargets text request.
* The result is stored in the fields in the session structure.
*
* Parameter:
* session The session
* key The text key to use
*
* Returns: 0 on success, else an error code.
*/
int
send_send_targets(session_t *session, uint8_t *key)
{
ccb_t *ccb;
pdu_t *pdu;
int rc = 0;
connection_t *conn;
DEB(9, ("Send_send_targets\n"));
conn = assign_connection(session, TRUE);
if (conn == NULL || conn->terminating || conn->state != ST_FULL_FEATURE)
return (conn != NULL && conn->terminating) ? conn->terminating
: ISCSI_STATUS_CONNECTION_FAILED;
ccb = get_ccb(conn, TRUE);
if (ccb == NULL)
return conn->terminating;
pdu = get_pdu(conn, TRUE);
if (pdu == NULL) {
free_ccb(ccb);
return conn->terminating;
}
ccb->flags |= CCBF_SENDTARGET;
if ((rc = assemble_send_targets(pdu, key)) != 0) {
free_ccb(ccb);
free_pdu(pdu);
return rc;
}
init_text_pdu(conn, pdu, NULL);
setup_tx_uio(pdu, pdu->temp_data_len, pdu->temp_data, FALSE);
send_pdu(ccb, pdu, CCBDISP_WAIT, PDUDISP_WAIT);
rc = ccb->status;
if (!rc) {
/* transfer ownership of data */
session->target_list = ccb->text_data;
session->target_list_len = ccb->text_len;
ccb->text_data = NULL;
}
free_ccb(ccb);
return rc;
}
/*
* send_nop_out:
* Send nop out request.
*
* Parameter:
* conn The connection
* rx_pdu The received Nop-In PDU
*
* Returns: 0 on success, else an error code.
*/
int
send_nop_out(connection_t *conn, pdu_t *rx_pdu)
{
ccb_t *ccb;
pdu_t *ppdu;
pdu_header_t *pdu;
DEBC(conn, 10, ("Send NOP_Out rx_pdu=%p\n", rx_pdu));
if (rx_pdu != NULL) {
ccb = NULL;
ppdu = get_pdu(conn, TRUE);
if (ppdu == NULL)
return 1;
} else {
ccb = get_ccb(conn, FALSE);
if (ccb == NULL) {
DEBOUT(("Can't get CCB in send_nop_out\n"));
return 1;
}
ppdu = get_pdu(conn, FALSE);
if (ppdu == NULL) {
free_ccb(ccb);
DEBOUT(("Can't get PDU in send_nop_out\n"));
return 1;
}
}
pdu = &ppdu->pdu;
pdu->Flags = FLAG_FINAL;
pdu->Opcode = IOP_NOP_Out | OP_IMMEDIATE;
if (rx_pdu != NULL) {
pdu->p.nop_out.TargetTransferTag =
rx_pdu->pdu.p.nop_in.TargetTransferTag;
pdu->InitiatorTaskTag = rx_pdu->pdu.InitiatorTaskTag;
pdu->p.nop_out.CmdSN = htonl(conn->session->CmdSN);
pdu->LUN = rx_pdu->pdu.LUN;
} else {
pdu->p.nop_out.TargetTransferTag = 0xffffffff;
ccb->CmdSN = ccb->session->CmdSN;
pdu->p.nop_out.CmdSN = htonl(ccb->CmdSN);
}
setup_tx_uio(ppdu, 0, NULL, FALSE);
send_pdu(ccb, ppdu, (rx_pdu != NULL) ? CCBDISP_NOWAIT : CCBDISP_FREE,
PDUDISP_FREE);
return 0;
}
/*
* snack_missing:
* Send SNACK request for missing data.
*
* Parameter:
* conn The connection
* ccb The task's CCB (for Data NAK only)
* type The SNACK type
* BegRun The BegRun field
* RunLength The RunLength field
*/
void
snack_missing(connection_t *conn, ccb_t *ccb, uint8_t type,
uint32_t BegRun, uint32_t RunLength)
{
pdu_t *ppdu;
pdu_header_t *pdu;
PDEBC(conn, 1, ("SNACK Missing type = %d, BegRun %d RunLength %d\n",
type, BegRun, RunLength));
ppdu = get_pdu(conn, TRUE);
if (ppdu == NULL)
return;
pdu = &ppdu->pdu;
pdu->Opcode = IOP_SNACK_Request;
pdu->Flags = FLAG_FINAL | type;
pdu->InitiatorTaskTag = (type == SNACK_DATA_NAK) ? ccb->ITT : 0xffffffff;
pdu->p.snack.TargetTransferTag = 0xffffffff;
pdu->p.snack.BegRun = htonl(BegRun);
pdu->p.snack.RunLength = htonl(RunLength);
ppdu->flags = PDUF_PRIORITY;
setup_tx_uio(ppdu, 0, NULL, FALSE);
send_pdu(NULL, ppdu, CCBDISP_NOWAIT, PDUDISP_FREE);
}
/*
* send_snack:
* Send SNACK request.
*
* Parameter:
* conn The connection
* rx_pdu The received data in PDU
* tx_ccb The original command CCB (required for Data ACK only)
* type The SNACK type
*
* Returns: 0 on success, else an error code.
*/
void
send_snack(connection_t *conn, pdu_t *rx_pdu, ccb_t *tx_ccb, uint8_t type)
{
pdu_t *ppdu;
pdu_header_t *pdu;
PDEBC(conn, 1, ("Send SNACK type = %d\n", type));
ppdu = get_pdu(conn, TRUE);
if (ppdu == NULL)
return;
pdu = &ppdu->pdu;
pdu->Opcode = IOP_SNACK_Request;
pdu->Flags = FLAG_FINAL | type;
switch (type) {
case SNACK_DATA_NAK:
pdu->InitiatorTaskTag = rx_pdu->pdu.InitiatorTaskTag;
pdu->p.snack.TargetTransferTag = 0xffffffff;
pdu->p.snack.BegRun = rx_pdu->pdu.p.data_in.DataSN;
pdu->p.snack.RunLength = htonl(1);
break;
case SNACK_STATUS_NAK:
pdu->InitiatorTaskTag = 0xffffffff;
pdu->p.snack.TargetTransferTag = 0xffffffff;
pdu->p.snack.BegRun = rx_pdu->pdu.p.response.StatSN;
pdu->p.snack.RunLength = htonl(1);
break;
case SNACK_DATA_ACK:
pdu->InitiatorTaskTag = 0xffffffff;
pdu->p.snack.TargetTransferTag =
rx_pdu->pdu.p.data_in.TargetTransferTag;
pdu->p.snack.BegRun = tx_ccb->DataSN_buf.ExpSN;
pdu->p.snack.RunLength = 0;
break;
default:
DEBOUT(("Invalid type %d in send_snack\n", type));
return;
}
pdu->LUN = rx_pdu->pdu.LUN;
ppdu->flags = PDUF_PRIORITY;
setup_tx_uio(ppdu, 0, NULL, FALSE);
send_pdu(NULL, ppdu, CCBDISP_NOWAIT, PDUDISP_FREE);
}
/*
* send_login:
* Send login request.
*
* Parameter:
* conn The connection
* par The login parameters (for negotiation)
*
* Returns: 0 on success, else an error code.
*/
int
send_login(connection_t *conn)
{
ccb_t *ccb;
pdu_t *pdu;
int rc;
DEBC(conn, 9, ("Send_login\n"));
ccb = get_ccb(conn, TRUE);
/* only if terminating (which couldn't possibly happen here, but...) */
if (ccb == NULL)
return conn->terminating;
pdu = get_pdu(conn, TRUE);
if (pdu == NULL) {
free_ccb(ccb);
return conn->terminating;
}
if ((rc = assemble_login_parameters(conn, ccb, pdu)) <= 0) {
init_login_pdu(conn, pdu, !rc);
setup_tx_uio(pdu, pdu->temp_data_len, pdu->temp_data, FALSE);
send_pdu(ccb, pdu, CCBDISP_WAIT, PDUDISP_FREE);
rc = ccb->status;
} else {
free_pdu(pdu);
}
free_ccb(ccb);
return rc;
}
/*
* send_logout:
* Send logout request.
* NOTE: This function does not wait for the logout to complete.
*
* Parameter:
* conn The connection
* refconn The referenced connection
* reason The reason code
* wait Wait for completion if TRUE
*
* Returns: 0 on success (logout sent), else an error code.
*/
int
send_logout(connection_t *conn, connection_t *refconn, int reason,
bool wait)
{
ccb_t *ccb;
pdu_t *ppdu;
pdu_header_t *pdu;
DEBC(conn, 5, ("Send_logout\n"));
ccb = get_ccb(conn, TRUE);
/* can only happen if terminating... */
if (ccb == NULL)
return conn->terminating;
ppdu = get_pdu(conn, TRUE);
if (ppdu == NULL) {
free_ccb(ccb);
return conn->terminating;
}
pdu = &ppdu->pdu;
pdu->Opcode = IOP_Logout_Request | OP_IMMEDIATE;
pdu->Flags = FLAG_FINAL | reason;
ccb->CmdSN = conn->session->CmdSN;
pdu->p.logout_req.CmdSN = htonl(ccb->CmdSN);
if (reason > 0)
pdu->p.logout_req.CID = htons(refconn->id);
ccb->par = refconn;
if (refconn != conn) {
ccb->flags |= CCBF_OTHERCONN;
} else {
conn->state = ST_LOGOUT_SENT;
conn->loggedout = LOGOUT_SENT;
}
setup_tx_uio(ppdu, 0, NULL, FALSE);
send_pdu(ccb, ppdu, (wait) ? CCBDISP_WAIT : CCBDISP_FREE, PDUDISP_FREE);
if (wait) {
int rc = ccb->status;
free_ccb (ccb);
return rc;
}
return 0;
}
/*
* send_task_management:
* Send task management request.
*
* Parameter:
* conn The connection
* ref_ccb The referenced command (NULL if none)
* xs The scsipi command structure (NULL if not a scsipi request)
* function The function code
*
* Returns: 0 on success, else an error code.
*/
int
send_task_management(connection_t *conn, ccb_t *ref_ccb, struct scsipi_xfer *xs,
int function)
{
ccb_t *ccb;
pdu_t *ppdu;
pdu_header_t *pdu;
DEBC(conn, 5, ("Send_task_management, ref_ccb=%p, func = %d\n",
ref_ccb, function));
if (function == TASK_REASSIGN && conn->session->ErrorRecoveryLevel < 2)
return ISCSI_STATUS_CANT_REASSIGN;
ccb = get_ccb(conn, xs == NULL);
/* can only happen if terminating... */
if (ccb == NULL)
return conn->terminating;
ppdu = get_pdu(conn, TRUE);
if (ppdu == NULL) {
free_ccb(ccb);
return conn->terminating;
}
ccb->xs = xs;
pdu = &ppdu->pdu;
pdu->Opcode = IOP_SCSI_Task_Management | OP_IMMEDIATE;
pdu->Flags = FLAG_FINAL | function;
ccb->CmdSN = conn->session->CmdSN;
pdu->p.task_req.CmdSN = htonl(ccb->CmdSN);
if (ref_ccb != NULL) {
pdu->p.task_req.ReferencedTaskTag = ref_ccb->ITT;
pdu->p.task_req.RefCmdSN = htonl(ref_ccb->CmdSN);
pdu->p.task_req.ExpDataSN = htonl(ref_ccb->DataSN_buf.ExpSN);
} else
pdu->p.task_req.ReferencedTaskTag = 0xffffffff;
ppdu->flags |= PDUF_PRIORITY;
setup_tx_uio(ppdu, 0, NULL, FALSE);
send_pdu(ccb, ppdu, (xs) ? CCBDISP_SCSIPI : CCBDISP_WAIT, PDUDISP_FREE);
if (xs == NULL) {
int rc = ccb->status;
free_ccb(ccb);
return rc;
}
return 0;
}
/*
* send_data_out:
* Send data to target in response to an R2T or as unsolicited data.
*
* Parameter:
* conn The connection
* rx_pdu The received R2T PDU (NULL if unsolicited)
* tx_ccb The originally sent command CCB
* waitok Whether it's OK to wait for an available PDU or not
*/
int
send_data_out(connection_t *conn, pdu_t *rx_pdu, ccb_t *tx_ccb,
ccb_disp_t disp, bool waitok)
{
pdu_header_t *pdu;
uint32_t totlen, len, offs, sn;
pdu_t *tx_pdu;
assert(conn->max_transfer != 0);
if (rx_pdu) {
offs = ntohl(rx_pdu->pdu.p.r2t.BufferOffset);
totlen = ntohl(rx_pdu->pdu.p.r2t.DesiredDataTransferLength);
} else {
offs = conn->max_firstimmed;
totlen = min(conn->max_firstdata - offs, tx_ccb->data_len - offs);
}
sn = 0;
while (totlen) {
len = min(totlen, conn->max_transfer);
tx_pdu = get_pdu(conn, waitok);
if (tx_pdu == NULL) {
DEBOUT(("No PDU in send_data_out\n"));
tx_ccb->disp = disp;
tx_ccb->status = ISCSI_STATUS_NO_RESOURCES;
handle_connection_error(conn, ISCSI_STATUS_NO_RESOURCES, NO_LOGOUT);
return ISCSI_STATUS_NO_RESOURCES;
}
totlen -= len;
pdu = &tx_pdu->pdu;
pdu->Opcode = IOP_SCSI_Data_out;
if (!totlen)
pdu->Flags = FLAG_FINAL;
if (rx_pdu != NULL)
pdu->p.data_out.TargetTransferTag =
rx_pdu->pdu.p.r2t.TargetTransferTag;
else
pdu->p.data_out.TargetTransferTag = 0xffffffff;
pdu->p.data_out.BufferOffset = htonl(offs);
pdu->p.data_out.DataSN = htonl(sn);
PERF_PDUSET(tx_pdu, tx_ccb, PERF_BEGIN_PDUWRITEDATA);
DEBC(conn, 10, ("Send DataOut: DataSN %d, len %d offs %x totlen %d\n",
sn, len, offs, totlen));
setup_tx_uio(tx_pdu, len, tx_ccb->data_ptr + offs, FALSE);
send_pdu(tx_ccb, tx_pdu, (totlen) ? CCBDISP_NOWAIT : disp, PDUDISP_FREE);
sn++;
offs += len;
}
return 0;
}
/*
* send_command:
* Send a SCSI command request.
*
* Parameter:
* CCB The CCB
* disp The CCB disposition
*/
void
send_command(ccb_t *ccb, ccb_disp_t disp, bool waitok, bool immed)
{
uint32_t totlen, len;
connection_t *conn = ccb->connection;
session_t *sess = ccb->session;
pdu_t *ppdu;
pdu_header_t *pdu;
int s;
PERF_BEGIN(ccb, !waitok);
s = splbio();
while (/*CONSTCOND*/ISCSI_THROTTLING_ENABLED &&
/*CONSTCOND*/ISCSI_SERVER_TRUSTED &&
!sn_a_le_b(sess->CmdSN, sess->MaxCmdSN)) {
ccb->disp = disp;
if (waitok)
ccb->flags |= CCBF_WAITING;
throttle_ccb(ccb, TRUE);
PDEBOUT(("Throttling S - CmdSN = %d, MaxCmdSN = %d\n",
sess->CmdSN, sess->MaxCmdSN));
if (!waitok) {
splx(s);
return;
}
tsleep(ccb, PWAIT, "waitMaxCmd", 0);
throttle_ccb(ccb, FALSE);
ccb->flags &= ~CCBF_WAITING;
}
splx(s);
ppdu = get_pdu(conn, FALSE);
if (ppdu == NULL) {
wake_ccb(ccb, ISCSI_STATUS_NO_RESOURCES);
return;
}
totlen = len = ccb->data_len;
pdu = &ppdu->pdu;
pdu->LUN = htonq(ccb->lun);
memcpy(pdu->p.command.SCSI_CDB, ccb->cmd, ccb->cmdlen);
pdu->Opcode = IOP_SCSI_Command;
if (immed)
pdu->Opcode |= OP_IMMEDIATE;
pdu->p.command.ExpectedDataTransferLength = htonl(totlen);
if (totlen) {
if (ccb->data_in) {
pdu->Flags = FLAG_READ;
totlen = 0;
} else {
pdu->Flags = FLAG_WRITE;
/* immediate data we can send */
len = min(totlen, conn->max_firstimmed);
/* can we send more unsolicited data ? */
totlen = conn->max_firstdata ? totlen - len : 0;
}
}
if (!totlen)
pdu->Flags |= FLAG_FINAL;
if (ccb->data_in)
init_sernum(&ccb->DataSN_buf);
ccb->sense_len_got = 0;
ccb->xfer_len = 0;
ccb->residual = 0;
ccb->flags |= CCBF_REASSIGN;
s = splbio();
ccb->CmdSN = sess->CmdSN;
if (!immed)
sess->CmdSN++;
splx(s);
pdu->p.command.CmdSN = htonl(ccb->CmdSN);
DEBC(conn, 10, ("Send Command: CmdSN %d, data_in %d, len %d, totlen %d\n",
ccb->CmdSN, ccb->data_in, len, totlen));
PERF_PDUSET(ppdu, ccb, PERF_BEGIN_PDUWRITECMD);
setup_tx_uio(ppdu, len, ccb->data_ptr, ccb->data_in);
send_pdu(ccb, ppdu, (totlen) ? CCBDISP_DEFER : disp, PDUDISP_WAIT);
if (totlen)
send_data_out(conn, NULL, ccb, disp, waitok);
}
/*
* send_run_xfer:
* Handle a SCSI command transfer request from scsipi.
*
* Parameter:
* session The session
* xs The transfer parameters
*/
void
send_run_xfer(session_t *session, struct scsipi_xfer *xs)
{
ccb_t *ccb;
connection_t *conn;
bool waitok;
waitok = !(xs->xs_control & XS_CTL_NOSLEEP);
DEB(10, ("RunXfer: flags=%x, data=%p, datalen=%d, resid=%d, cmdlen=%d, "
"waitok=%d\n", xs->xs_control, xs->data, xs->datalen,
xs->resid, xs->cmdlen, waitok));
conn = assign_connection(session, waitok);
if (conn == NULL || conn->terminating || conn->state != ST_FULL_FEATURE) {
xs->error = XS_SELTIMEOUT;
DEBC(conn, 10, ("run_xfer on dead connection\n"));
scsipi_done(xs);
return;
}
if (xs->xs_control & XS_CTL_RESET) {
if (send_task_management(conn, NULL, xs, TARGET_WARM_RESET)) {
xs->error = XS_SELTIMEOUT;
scsipi_done(xs);
}
return;
}
ccb = get_ccb(conn, waitok);
if (ccb == NULL) {
xs->error = XS_BUSY;
xs->status = SCSI_QUEUE_FULL;
DEBC(conn, 0, ("No CCB in run_xfer\n"));
scsipi_done(xs);
return;
}
/* copy parameters into CCB for easier access */
ccb->xs = xs;
ccb->data_in = (xs->xs_control & XS_CTL_DATA_IN) != 0;
ccb->data_len = (uint32_t) xs->datalen;
ccb->data_ptr = xs->data;
ccb->sense_len_req = sizeof(xs->sense.scsi_sense);
ccb->sense_ptr = &xs->sense;
ccb->lun = ((uint64_t) (uint8_t) xs->xs_periph->periph_lun) << 48;
ccb->cmd = (uint8_t *) xs->cmd;
ccb->cmdlen = xs->cmdlen;
DEB(10, ("RunXfer: Periph_lun = %d, cmd[1] = %x, cmdlen = %d\n",
xs->xs_periph->periph_lun, ccb->cmd[1], xs->cmdlen));
#ifdef LUN_1
ccb->lun += 0x1000000000000LL;
ccb->cmd[1] += 0x10;
#endif
send_command(ccb, CCBDISP_SCSIPI, waitok, FALSE);
}
#ifndef ISCSI_MINIMAL
/*
* send_io_command:
* Handle a SCSI io command request from user space.
*
* Parameter:
* session The session
* lun The LUN to use
* req The SCSI request block
* immed Immediate command if TRUE
* conn_id Assign to this connection ID if nonzero
*/
int
send_io_command(session_t *session, uint64_t lun, scsireq_t *req,
bool immed, uint32_t conn_id)
{
ccb_t *ccb;
connection_t *conn;
int rc;
DEB(9, ("IoCommand: lun=%x, datalen=%d, cmdlen=%d, immed=%d, cid=%d\n",
(int) lun, (int) req->datalen, (int) req->cmdlen, immed, conn_id));
conn = (conn_id) ? find_connection(session, conn_id)
: assign_connection(session, TRUE);
if (conn == NULL || conn->terminating || conn->state != ST_FULL_FEATURE) {
DEBOUT(("io_command on dead connection (state = %d)\n",
(conn != NULL) ? conn->state : -1));
return ISCSI_STATUS_INVALID_CONNECTION_ID;
}
ccb = get_ccb(conn, TRUE);
if (ccb == NULL) {
DEBOUT(("No CCB in io_command\n"));
return ISCSI_STATUS_NO_RESOURCES;
}
ccb->data_in = (req->flags & SCCMD_READ) != 0;
ccb->data_len = (uint32_t) req->datalen;
ccb->data_ptr = req->databuf;
ccb->sense_len_req = req->senselen;
ccb->sense_ptr = &req->sense;
ccb->lun = lun;
ccb->cmd = (uint8_t *) req->cmd;
ccb->cmdlen = req->cmdlen;
DEBC(conn, 10, ("IoCommand: cmd[1] = %x, cmdlen = %d\n",
ccb->cmd[1], ccb->cmdlen));
send_command(ccb, CCBDISP_WAIT, TRUE, immed);
rc = ccb->status;
req->senselen_used = ccb->sense_len_got;
req->datalen_used = req->datalen - ccb->residual;
free_ccb(ccb);
return rc;
}
#endif
/*****************************************************************************
* Timeout handlers
*****************************************************************************/
/*
* connection_timeout:
* Handle prolonged silence on a connection by checking whether
* it's still alive.
* This has the side effect of discovering missing status or lost commands
* before those time out.
*
* Parameter:
* par The connection
*/
void
connection_timeout(void *par)
{
connection_t *conn = (connection_t *) par;
PDEBC(conn, 1, ("Connection Timeout, num_timeouts=%d\n",
conn->num_timeouts));
if (++conn->num_timeouts > MAX_CONN_TIMEOUTS)
handle_connection_error(conn, ISCSI_STATUS_TIMEOUT, NO_LOGOUT);
else {
if (conn->state == ST_FULL_FEATURE)
send_nop_out(conn, NULL);
SET_CONN_TIMEOUT(conn, CONNECTION_TIMEOUT);
}
}
/*
* ccb_timeout:
* Handle timeout of a sent command.
*
* Parameter:
* par The CCB
*/
void
ccb_timeout(void *par)
{
ccb_t *ccb = (ccb_t *) par;
connection_t *conn = ccb->connection;
PDEBC(conn, 1, ("CCB Timeout, ccb=%x, num_timeouts=%d\n",
(int) ccb, ccb->num_timeouts));
ccb->total_tries++;
if (++ccb->num_timeouts > MAX_CCB_TIMEOUTS ||
ccb->total_tries > MAX_CCB_TRIES ||
ccb->disp <= CCBDISP_FREE ||
!ccb->session->ErrorRecoveryLevel) {
wake_ccb(ccb, ISCSI_STATUS_TIMEOUT);
handle_connection_error(conn, ISCSI_STATUS_TIMEOUT, RECOVER_CONNECTION);
} else {
if (ccb->data_in && ccb->xfer_len < ccb->data_len) {
/* request resend of all missing data */
snack_missing(conn, ccb, SNACK_DATA_NAK, 0, 0);
} else {
/* request resend of all missing status */
snack_missing(conn, NULL, SNACK_STATUS_NAK, 0, 0);
}
SET_CCB_TIMEOUT(conn, ccb, COMMAND_TIMEOUT);
}
}
Reference in New Issue View Git Blame Copy Permalink