mirror of
https://github.com/xcat2/xNBA.git
synced 2024-12-14 23:31:39 +00:00
Provide a SCSI device interface to the iSCSI protocol
This commit is contained in:
Michael Brown
parent
f33f01c126
commit
5009f8d6a2
@ -81,6 +81,60 @@ struct iscsi_bhs_common {
|
||||
/** Final PDU of a sequence */
|
||||
#define ISCSI_FLAG_FINAL 0x80
|
||||
|
||||
/**
|
||||
* iSCSI basic header segment common request fields
|
||||
*
|
||||
*/
|
||||
struct iscsi_bhs_common_request {
|
||||
/** Opcode */
|
||||
uint8_t opcode;
|
||||
/** Flags */
|
||||
uint8_t flags;
|
||||
/** Fields specific to the PDU type */
|
||||
uint8_t other_a[2];
|
||||
/** Segment lengths */
|
||||
union iscsi_segment_lengths lengths;
|
||||
/** Fields specific to the PDU type */
|
||||
uint8_t other_b[8];
|
||||
/** Initiator Task Tag */
|
||||
uint32_t itt;
|
||||
/** Fields specific to the PDU type */
|
||||
uint8_t other_c[4];
|
||||
/** Command sequence number */
|
||||
uint32_t cmdsn;
|
||||
/** Expected status sequence number */
|
||||
uint32_t expstatsn;
|
||||
/** Fields specific to the PDU type */
|
||||
uint8_t other_d[16];
|
||||
};
|
||||
|
||||
/**
|
||||
* iSCSI basic header segment common request fields
|
||||
*
|
||||
*/
|
||||
struct iscsi_bhs_common_response {
|
||||
/** Opcode */
|
||||
uint8_t opcode;
|
||||
/** Flags */
|
||||
uint8_t flags;
|
||||
/** Fields specific to the PDU type */
|
||||
uint8_t other_a[2];
|
||||
/** Segment lengths */
|
||||
union iscsi_segment_lengths lengths;
|
||||
/** Fields specific to the PDU type */
|
||||
uint8_t other_b[8];
|
||||
/** Initiator Task Tag */
|
||||
uint32_t itt;
|
||||
/** Fields specific to the PDU type */
|
||||
uint8_t other_c[4];
|
||||
/** Status sequence number */
|
||||
uint32_t statsn;
|
||||
/** Expected command sequence number */
|
||||
uint32_t expcmdsn;
|
||||
/** Fields specific to the PDU type */
|
||||
uint8_t other_d[16];
|
||||
};
|
||||
|
||||
/**
|
||||
* iSCSI login request basic header segment
|
||||
*
|
||||
@ -203,7 +257,7 @@ struct iscsi_bhs_scsi_command {
|
||||
/** Segment lengths */
|
||||
union iscsi_segment_lengths lengths;
|
||||
/** SCSI Logical Unit Number */
|
||||
uint8_t lun[8];
|
||||
uint64_t lun;
|
||||
/** Initiator Task Tag */
|
||||
uint32_t itt;
|
||||
/** Expected data transfer length */
|
||||
@ -290,7 +344,7 @@ struct iscsi_bhs_data_in {
|
||||
/** Segment lengths */
|
||||
union iscsi_segment_lengths lengths;
|
||||
/** Logical Unit Number */
|
||||
uint8_t lun[8];
|
||||
uint64_t lun;
|
||||
/** Initiator Task Tag */
|
||||
uint32_t itt;
|
||||
/** Target Transfer Tag */
|
||||
@ -329,6 +383,8 @@ struct iscsi_bhs_data_in {
|
||||
*/
|
||||
union iscsi_bhs {
|
||||
struct iscsi_bhs_common common;
|
||||
struct iscsi_bhs_common_request common_request;
|
||||
struct iscsi_bhs_common_response common_response;
|
||||
struct iscsi_bhs_login_request login_request;
|
||||
struct iscsi_bhs_login_response login_response;
|
||||
struct iscsi_bhs_scsi_command scsi_command;
|
||||
@ -339,12 +395,10 @@ union iscsi_bhs {
|
||||
|
||||
/** State */
|
||||
enum iscsi_state {
|
||||
/** In the process of logging in */
|
||||
ISCSI_STATE_FAILED = -1,
|
||||
ISCSI_STATE_NOT_CONNECTED = 0,
|
||||
ISCSI_STATE_IDLE,
|
||||
ISCSI_STATE_LOGGING_IN,
|
||||
ISCSI_STATE_READING_DATA,
|
||||
ISCSI_STATE_LOGIN,
|
||||
ISCSI_STATE_LOGIN_CONT,
|
||||
ISCSI_STATE_COMMAND,
|
||||
};
|
||||
|
||||
/** State of an iSCSI TX engine */
|
||||
@ -377,40 +431,32 @@ enum iscsi_rx_state {
|
||||
struct iscsi_session {
|
||||
/** TCP connection for this session */
|
||||
struct tcp_connection tcp;
|
||||
/** Session status
|
||||
*
|
||||
* This is the bitwise-OR of zero or more ISCSI_STATUS_XXX
|
||||
* constants.
|
||||
*/
|
||||
int status;
|
||||
/** Retry count
|
||||
*
|
||||
* Number of times that the connection has been retried.
|
||||
* Reset upon a successful connection.
|
||||
*/
|
||||
int retry_count;
|
||||
|
||||
/** Initiator IQN */
|
||||
const char *initiator;
|
||||
/** Target IQN */
|
||||
const char *target;
|
||||
/** Logical Unit Number (LUN) */
|
||||
uint64_t lun;
|
||||
|
||||
/** Block size in bytes */
|
||||
size_t block_size;
|
||||
/** Starting block number of the current data transfer */
|
||||
unsigned long block_start;
|
||||
/** Block count of the current data transfer */
|
||||
unsigned long block_count;
|
||||
/** Block read callback function
|
||||
*
|
||||
* Note that this may be called several times, since it is
|
||||
* called per-packet rather than per-block.
|
||||
*/
|
||||
void ( * block_read_callback ) ( void *private, const void *data,
|
||||
unsigned long offset, size_t len );
|
||||
/** Block read callback private data
|
||||
*
|
||||
* This is passed to block_read_callback()
|
||||
*/
|
||||
void *block_read_private;
|
||||
|
||||
/** State of the session */
|
||||
enum iscsi_state state;
|
||||
/** Target session identifying handle
|
||||
*
|
||||
* This is assigned by the target when we first log in, and
|
||||
* must be reused on subsequent login attempts.
|
||||
*/
|
||||
uint16_t tsih;
|
||||
|
||||
/** Initiator task tag
|
||||
*
|
||||
* This is the tag of the current command. It is incremented
|
||||
@ -447,14 +493,34 @@ struct iscsi_session {
|
||||
enum iscsi_rx_state rx_state;
|
||||
/** Byte offset within the current RX state */
|
||||
size_t rx_offset;
|
||||
|
||||
/** Current SCSI command
|
||||
*
|
||||
* Set to NULL when command is complete.
|
||||
*/
|
||||
struct scsi_command *command;
|
||||
};
|
||||
|
||||
static inline int iscsi_busy ( struct iscsi_session *iscsi ) {
|
||||
return ( iscsi->state > ISCSI_STATE_IDLE );
|
||||
}
|
||||
/** Session is currently connected */
|
||||
#define ISCSI_STATUS_CONNECTED 0x01
|
||||
|
||||
static inline int iscsi_error ( struct iscsi_session *iscsi ) {
|
||||
return ( iscsi->state == ISCSI_STATE_FAILED );
|
||||
}
|
||||
/** Session has completed */
|
||||
#define ISCSI_STATUS_DONE 0x02
|
||||
|
||||
/** Session failed */
|
||||
#define ISCSI_STATUS_ERR 0x04
|
||||
|
||||
/** Maximum number of retries at connecting */
|
||||
#define ISCSI_MAX_RETRIES 2
|
||||
|
||||
/** An iSCSI device */
|
||||
struct iscsi_device {
|
||||
/** SCSI device interface */
|
||||
struct scsi_device scsi;
|
||||
/** iSCSI protocol instance */
|
||||
struct iscsi_session iscsi;
|
||||
};
|
||||
|
||||
extern int init_iscsidev ( struct iscsi_device *iscsidev );
|
||||
|
||||
#endif /* _GPXE_ISCSI_H */
|
||||
|
||||
591
src/net/tcp/iscsi.c
Normal file
591
src/net/tcp/iscsi.c
Normal file
@ -0,0 +1,591 @@
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
#include <vsprintf.h>
|
||||
#include <errno.h>
|
||||
#include <assert.h>
|
||||
#include <byteswap.h>
|
||||
#include <gpxe/scsi.h>
|
||||
#include <gpxe/process.h>
|
||||
#include <gpxe/iscsi.h>
|
||||
|
||||
/** @file
|
||||
*
|
||||
* iSCSI protocol
|
||||
*
|
||||
*/
|
||||
|
||||
static void iscsi_start_tx ( struct iscsi_session *iscsi );
|
||||
|
||||
/****************************************************************************
|
||||
*
|
||||
* iSCSI SCSI command issuing
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* Build iSCSI SCSI command BHS
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
*/
|
||||
static void iscsi_start_command ( struct iscsi_session *iscsi ) {
|
||||
struct iscsi_bhs_scsi_command *command = &iscsi->tx_bhs.scsi_command;
|
||||
|
||||
assert ( ! ( iscsi->command->data_in && iscsi->command->data_out ) );
|
||||
|
||||
/* Construct BHS and initiate transmission */
|
||||
iscsi_start_tx ( iscsi );
|
||||
command->opcode = ISCSI_OPCODE_SCSI_COMMAND;
|
||||
command->flags = ( ISCSI_FLAG_FINAL |
|
||||
ISCSI_COMMAND_ATTR_SIMPLE );
|
||||
if ( iscsi->command->data_in )
|
||||
command->flags |= ISCSI_COMMAND_FLAG_READ;
|
||||
if ( iscsi->command->data_out )
|
||||
command->flags |= ISCSI_COMMAND_FLAG_WRITE;
|
||||
ISCSI_SET_LENGTHS ( command->lengths, 0, iscsi->command->data_out_len);
|
||||
command->lun = iscsi->lun;
|
||||
command->itt = htonl ( iscsi->itt );
|
||||
command->exp_len = htonl ( iscsi->command->data_in_len );
|
||||
memcpy ( &command->cdb, &iscsi->command->cdb, sizeof ( command->cdb ));
|
||||
}
|
||||
|
||||
/**
|
||||
* Send iSCSI SCSI command data
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
*/
|
||||
static void iscsi_tx_command ( struct iscsi_session *iscsi ) {
|
||||
tcp_send ( &iscsi->tcp, iscsi->command->data_out + iscsi->tx_offset,
|
||||
iscsi->command->data_out_len - iscsi->tx_offset );
|
||||
}
|
||||
|
||||
/**
|
||||
* Receive data segment of an iSCSI data-in PDU
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
* @v data Received data
|
||||
* @v len Length of received data
|
||||
* @v remaining Data remaining after this data
|
||||
*
|
||||
*/
|
||||
static void iscsi_rx_data_in ( struct iscsi_session *iscsi, void *data,
|
||||
size_t len, size_t remaining ) {
|
||||
struct iscsi_bhs_data_in *data_in = &iscsi->rx_bhs.data_in;
|
||||
unsigned long offset;
|
||||
|
||||
/* Copy data to data-in buffer */
|
||||
offset = ntohl ( data_in->offset ) + iscsi->rx_offset;
|
||||
assert ( iscsi->command != NULL );
|
||||
assert ( iscsi->command->data_in != NULL );
|
||||
assert ( ( offset + len ) <= iscsi->command->data_in_len );
|
||||
memcpy ( ( iscsi->command->data_in + offset ), data, len );
|
||||
|
||||
/* If this is the end, flag as complete */
|
||||
if ( ( data_in->flags & ISCSI_FLAG_FINAL ) && ( remaining == 0 ) )
|
||||
iscsi->status |= ISCSI_STATUS_DONE;
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
*
|
||||
* iSCSI login
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* Build iSCSI login request strings
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
*
|
||||
* These are the initial set of strings sent in the first login
|
||||
* request PDU.
|
||||
*/
|
||||
static int iscsi_build_login_request_strings ( struct iscsi_session *iscsi,
|
||||
void *data, size_t len ) {
|
||||
return snprintf ( data, len,
|
||||
"InitiatorName=%s%c"
|
||||
"TargetName=%s%c"
|
||||
"MaxRecvDataSegmentLength=512%c"
|
||||
"SessionType=Normal%c"
|
||||
"DataDigest=None%c"
|
||||
"HeaderDigest=None%c",
|
||||
iscsi->initiator, 0, iscsi->target, 0,
|
||||
0, 0, 0, 0 );
|
||||
}
|
||||
|
||||
/**
|
||||
* Build iSCSI login request BHS
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
* @v first Login request is the first request of a session
|
||||
*/
|
||||
static void iscsi_start_login ( struct iscsi_session *iscsi, int first ) {
|
||||
struct iscsi_bhs_login_request *request = &iscsi->tx_bhs.login_request;
|
||||
int len;
|
||||
|
||||
/* Construct BHS and initiate transmission */
|
||||
iscsi_start_tx ( iscsi );
|
||||
request->opcode = ( ISCSI_OPCODE_LOGIN_REQUEST |
|
||||
ISCSI_FLAG_IMMEDIATE );
|
||||
request->flags = ( ISCSI_LOGIN_FLAG_TRANSITION |
|
||||
ISCSI_LOGIN_CSG_OPERATIONAL_NEGOTIATION |
|
||||
ISCSI_LOGIN_NSG_FULL_FEATURE_PHASE );
|
||||
/* version_max and version_min left as zero */
|
||||
if ( first ) {
|
||||
len = iscsi_build_login_request_strings ( iscsi, NULL, 0 );
|
||||
ISCSI_SET_LENGTHS ( request->lengths, 0, len );
|
||||
}
|
||||
request->isid_iana_en = htonl ( ISCSI_ISID_IANA |
|
||||
IANA_EN_FEN_SYSTEMS );
|
||||
/* isid_iana_qual left as zero */
|
||||
request->tsih = htons ( iscsi->tsih );
|
||||
/* itt left as zero */
|
||||
/* cid left as zero */
|
||||
}
|
||||
|
||||
/**
|
||||
* Transmit data segment of an iSCSI login request PDU
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
*
|
||||
* For login requests, the data segment consists of the login strings.
|
||||
*/
|
||||
static void iscsi_tx_login_request ( struct iscsi_session *iscsi ) {
|
||||
int len;
|
||||
|
||||
len = iscsi_build_login_request_strings ( iscsi, tcp_buffer,
|
||||
tcp_buflen );
|
||||
tcp_send ( &iscsi->tcp, tcp_buffer + iscsi->tx_offset,
|
||||
len - iscsi->tx_offset );
|
||||
}
|
||||
|
||||
/**
|
||||
* Receive data segment of an iSCSI login response PDU
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
* @v data Received data
|
||||
* @v len Length of received data
|
||||
* @v remaining Data remaining after this data
|
||||
*
|
||||
*/
|
||||
static void iscsi_rx_login_response ( struct iscsi_session *iscsi,
|
||||
void *data __unused,
|
||||
size_t len __unused,
|
||||
size_t remaining __unused ) {
|
||||
struct iscsi_bhs_login_response *response
|
||||
= &iscsi->rx_bhs.login_response;
|
||||
|
||||
/* Check for fatal errors */
|
||||
if ( response->status_class != 0 ) {
|
||||
printf ( "iSCSI login failure: class %02x detail %02x\n",
|
||||
response->status_class, response->status_detail );
|
||||
iscsi->status |= ( ISCSI_STATUS_DONE | ISCSI_STATUS_ERR );
|
||||
tcp_close ( &iscsi->tcp );
|
||||
return;
|
||||
}
|
||||
|
||||
/* If server did not transition, send back another login
|
||||
* request without any login strings.
|
||||
*/
|
||||
if ( ! ( response->flags & ISCSI_LOGIN_FLAG_TRANSITION ) ) {
|
||||
iscsi_start_login ( iscsi, 0 );
|
||||
return;
|
||||
}
|
||||
|
||||
/* Record TSIH for future reference */
|
||||
iscsi->tsih = ntohl ( response->tsih );
|
||||
|
||||
/* Send the SCSI command */
|
||||
iscsi_start_command ( iscsi );
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
*
|
||||
* iSCSI to TCP interface
|
||||
*
|
||||
*/
|
||||
|
||||
static inline struct iscsi_session *
|
||||
tcp_to_iscsi ( struct tcp_connection *conn ) {
|
||||
return container_of ( conn, struct iscsi_session, tcp );
|
||||
}
|
||||
|
||||
/**
|
||||
* Start up a new TX PDU
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
*
|
||||
* This initiates the process of sending a new PDU. Only one PDU may
|
||||
* be in transit at any one time.
|
||||
*/
|
||||
static void iscsi_start_tx ( struct iscsi_session *iscsi ) {
|
||||
assert ( iscsi->tx_state == ISCSI_TX_IDLE );
|
||||
|
||||
/* Initialise TX BHS */
|
||||
memset ( &iscsi->tx_bhs, 0, sizeof ( iscsi->tx_bhs ) );
|
||||
iscsi->tx_bhs.common_request.cmdsn = htonl ( iscsi->cmdsn );
|
||||
iscsi->tx_bhs.common_request.expstatsn = htonl ( iscsi->statsn + 1 );
|
||||
|
||||
/* Flag TX engine to start transmitting */
|
||||
iscsi->tx_state = ISCSI_TX_BHS;
|
||||
iscsi->tx_offset = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Transmit data segment of an iSCSI PDU
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
*
|
||||
* Handle transmission of part of a PDU data segment. iscsi::tx_bhs
|
||||
* will be valid when this is called.
|
||||
*/
|
||||
static void iscsi_tx_data ( struct iscsi_session *iscsi ) {
|
||||
struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
|
||||
|
||||
switch ( common->opcode & ISCSI_OPCODE_MASK ) {
|
||||
case ISCSI_OPCODE_SCSI_COMMAND:
|
||||
iscsi_tx_command ( iscsi );
|
||||
break;
|
||||
case ISCSI_OPCODE_LOGIN_REQUEST:
|
||||
iscsi_tx_login_request ( iscsi );
|
||||
break;
|
||||
default:
|
||||
assert ( 0 );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle TCP ACKs
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
*
|
||||
* Updates iscsi->tx_offset and, if applicable, transitions to the
|
||||
* next TX state.
|
||||
*/
|
||||
static void iscsi_acked ( struct tcp_connection *conn, size_t len ) {
|
||||
struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
|
||||
struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
|
||||
size_t max_tx_offset;
|
||||
enum iscsi_tx_state next_state;
|
||||
|
||||
iscsi->tx_offset += len;
|
||||
while ( 1 ) {
|
||||
switch ( iscsi->tx_state ) {
|
||||
case ISCSI_TX_BHS:
|
||||
max_tx_offset = sizeof ( iscsi->tx_bhs );
|
||||
next_state = ISCSI_TX_AHS;
|
||||
break;
|
||||
case ISCSI_TX_AHS:
|
||||
max_tx_offset = 4 * ISCSI_AHS_LEN ( common->lengths );
|
||||
next_state = ISCSI_TX_DATA;
|
||||
break;
|
||||
case ISCSI_TX_DATA:
|
||||
max_tx_offset = ISCSI_DATA_LEN ( common->lengths );
|
||||
next_state = ISCSI_TX_DATA_PADDING;
|
||||
break;
|
||||
case ISCSI_TX_DATA_PADDING:
|
||||
max_tx_offset = ISCSI_DATA_PAD_LEN ( common->lengths );
|
||||
next_state = ISCSI_TX_IDLE;
|
||||
break;
|
||||
case ISCSI_TX_IDLE:
|
||||
return;
|
||||
default:
|
||||
assert ( 0 );
|
||||
return;
|
||||
}
|
||||
assert ( iscsi->tx_offset <= max_tx_offset );
|
||||
|
||||
/* If the whole of the current portion has not yet
|
||||
* been acked, stay in this state for now.
|
||||
*/
|
||||
if ( iscsi->tx_offset != max_tx_offset )
|
||||
return;
|
||||
|
||||
iscsi->tx_state = next_state;
|
||||
iscsi->tx_offset = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Transmit iSCSI PDU
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
*
|
||||
* Constructs data to be sent for the current TX state
|
||||
*/
|
||||
static void iscsi_senddata ( struct tcp_connection *conn ) {
|
||||
struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
|
||||
struct iscsi_bhs_common *common = &iscsi->tx_bhs.common;
|
||||
static const char pad[] = { '\0', '\0', '\0' };
|
||||
|
||||
switch ( iscsi->tx_state ) {
|
||||
case ISCSI_TX_IDLE:
|
||||
/* Nothing to send */
|
||||
break;
|
||||
case ISCSI_TX_BHS:
|
||||
tcp_send ( conn, &iscsi->tx_bhs.bytes[iscsi->tx_offset],
|
||||
( sizeof ( iscsi->tx_bhs ) - iscsi->tx_offset ) );
|
||||
break;
|
||||
case ISCSI_TX_AHS:
|
||||
/* We don't yet have an AHS transmission mechanism */
|
||||
assert ( 0 );
|
||||
break;
|
||||
case ISCSI_TX_DATA:
|
||||
iscsi_tx_data ( iscsi );
|
||||
break;
|
||||
case ISCSI_TX_DATA_PADDING:
|
||||
tcp_send ( conn, pad, ( ISCSI_DATA_PAD_LEN ( common->lengths )
|
||||
- iscsi->tx_offset ) );
|
||||
break;
|
||||
default:
|
||||
assert ( 0 );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Receive data segment of an iSCSI PDU
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
* @v data Received data
|
||||
* @v len Length of received data
|
||||
* @v remaining Data remaining after this data
|
||||
*
|
||||
* Handle processing of part of a PDU data segment. iscsi::rx_bhs
|
||||
* will be valid when this is called.
|
||||
*/
|
||||
static void iscsi_rx_data ( struct iscsi_session *iscsi, void *data,
|
||||
size_t len, size_t remaining ) {
|
||||
struct iscsi_bhs_common_response *response
|
||||
= &iscsi->rx_bhs.common_response;
|
||||
|
||||
/* Update cmdsn and statsn */
|
||||
iscsi->cmdsn = ntohl ( response->expcmdsn );
|
||||
iscsi->statsn = ntohl ( response->statsn );
|
||||
|
||||
/* Increment itt when we receive a final response */
|
||||
if ( response->flags & ISCSI_FLAG_FINAL )
|
||||
iscsi->itt++;
|
||||
|
||||
switch ( response->opcode & ISCSI_OPCODE_MASK ) {
|
||||
case ISCSI_OPCODE_LOGIN_RESPONSE:
|
||||
iscsi_rx_login_response ( iscsi, data, len, remaining );
|
||||
break;
|
||||
case ISCSI_OPCODE_DATA_IN:
|
||||
iscsi_rx_data_in ( iscsi, data, len, remaining );
|
||||
break;
|
||||
default:
|
||||
printf ( "Unknown iSCSI opcode %02x\n", response->opcode );
|
||||
iscsi->status |= ( ISCSI_STATUS_DONE | ISCSI_STATUS_ERR );
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Discard portion of an iSCSI PDU.
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
* @v data Received data
|
||||
* @v len Length of received data
|
||||
* @v remaining Data remaining after this data
|
||||
*
|
||||
* This discards data from a portion of a received PDU.
|
||||
*/
|
||||
static void iscsi_rx_discard ( struct iscsi_session *iscsi __unused,
|
||||
void *data __unused, size_t len __unused,
|
||||
size_t remaining __unused ) {
|
||||
/* Do nothing */
|
||||
}
|
||||
|
||||
/**
|
||||
* Receive basic header segment of an iSCSI PDU
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
* @v data Received data
|
||||
* @v len Length of received data
|
||||
* @v remaining Data remaining after this data
|
||||
*
|
||||
* This fills in iscsi::rx_bhs with the data from the BHS portion of
|
||||
* the received PDU.
|
||||
*/
|
||||
static void iscsi_rx_bhs ( struct iscsi_session *iscsi, void *data,
|
||||
size_t len, size_t remaining __unused ) {
|
||||
memcpy ( &iscsi->rx_bhs.bytes[iscsi->rx_offset], data, len );
|
||||
}
|
||||
|
||||
/**
|
||||
* Receive new data
|
||||
*
|
||||
* @v tcp TCP connection
|
||||
* @v data Received data
|
||||
* @v len Length of received data
|
||||
*
|
||||
* This handles received PDUs. The receive strategy is to fill in
|
||||
* iscsi::rx_bhs with the contents of the BHS portion of the PDU,
|
||||
* throw away any AHS portion, and then process each part of the data
|
||||
* portion as it arrives. The data processing routine therefore
|
||||
* always has a full copy of the BHS available, even for portions of
|
||||
* the data in different packets to the BHS.
|
||||
*/
|
||||
static void iscsi_newdata ( struct tcp_connection *conn, void *data,
|
||||
size_t len ) {
|
||||
struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
|
||||
struct iscsi_bhs_common *common = &iscsi->rx_bhs.common;
|
||||
void ( *process ) ( struct iscsi_session *iscsi, void *data,
|
||||
size_t len, size_t remaining );
|
||||
size_t max_rx_offset;
|
||||
enum iscsi_rx_state next_state;
|
||||
size_t frag_len;
|
||||
size_t remaining;
|
||||
|
||||
while ( 1 ) {
|
||||
switch ( iscsi->rx_state ) {
|
||||
case ISCSI_RX_BHS:
|
||||
process = iscsi_rx_bhs;
|
||||
max_rx_offset = sizeof ( iscsi->rx_bhs );
|
||||
next_state = ISCSI_RX_AHS;
|
||||
break;
|
||||
case ISCSI_RX_AHS:
|
||||
process = iscsi_rx_discard;
|
||||
max_rx_offset = 4 * ISCSI_AHS_LEN ( common->lengths );
|
||||
next_state = ISCSI_RX_DATA;
|
||||
break;
|
||||
case ISCSI_RX_DATA:
|
||||
process = iscsi_rx_data;
|
||||
max_rx_offset = ISCSI_DATA_LEN ( common->lengths );
|
||||
next_state = ISCSI_RX_DATA_PADDING;
|
||||
break;
|
||||
case ISCSI_RX_DATA_PADDING:
|
||||
process = iscsi_rx_discard;
|
||||
max_rx_offset = ISCSI_DATA_PAD_LEN ( common->lengths );
|
||||
next_state = ISCSI_RX_BHS;
|
||||
break;
|
||||
default:
|
||||
assert ( 0 );
|
||||
return;
|
||||
}
|
||||
|
||||
frag_len = max_rx_offset - iscsi->rx_offset;
|
||||
if ( frag_len > len )
|
||||
frag_len = len;
|
||||
remaining = max_rx_offset - iscsi->rx_offset - frag_len;
|
||||
process ( iscsi, data, frag_len, remaining );
|
||||
|
||||
iscsi->rx_offset += frag_len;
|
||||
data += frag_len;
|
||||
len -= frag_len;
|
||||
|
||||
/* If all the data for this state has not yet been
|
||||
* received, stay in this state for now.
|
||||
*/
|
||||
if ( iscsi->rx_offset != max_rx_offset )
|
||||
return;
|
||||
|
||||
iscsi->rx_state = next_state;
|
||||
iscsi->rx_offset = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle TCP connection closure
|
||||
*
|
||||
* @v conn TCP connection
|
||||
* @v status Error code, if any
|
||||
*
|
||||
*/
|
||||
static void iscsi_closed ( struct tcp_connection *conn, int status __unused ) {
|
||||
struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
|
||||
|
||||
/* Clear connected flag */
|
||||
iscsi->status &= ~ISCSI_STATUS_CONNECTED;
|
||||
|
||||
/* Retry connection if within the retry limit, otherwise fail */
|
||||
if ( ++iscsi->retry_count <= ISCSI_MAX_RETRIES ) {
|
||||
tcp_connect ( conn );
|
||||
} else {
|
||||
iscsi->status |= ( ISCSI_STATUS_DONE | ISCSI_STATUS_ERR );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle TCP connection opening
|
||||
*
|
||||
* @v conn TCP connection
|
||||
*
|
||||
*/
|
||||
static void iscsi_connected ( struct tcp_connection *conn ) {
|
||||
struct iscsi_session *iscsi = tcp_to_iscsi ( conn );
|
||||
|
||||
/* Set connected flag and reset retry count */
|
||||
iscsi->status |= ISCSI_STATUS_CONNECTED;
|
||||
iscsi->retry_count = 0;
|
||||
|
||||
/* Prepare to receive PDUs. */
|
||||
iscsi->rx_state = ISCSI_RX_BHS;
|
||||
iscsi->rx_offset = 0;
|
||||
|
||||
/* Start logging in */
|
||||
iscsi_start_login ( iscsi, 1 );
|
||||
}
|
||||
|
||||
/** iSCSI TCP operations */
|
||||
static struct tcp_operations iscsi_tcp_operations = {
|
||||
.closed = iscsi_closed,
|
||||
.connected = iscsi_connected,
|
||||
.acked = iscsi_acked,
|
||||
.newdata = iscsi_newdata,
|
||||
.senddata = iscsi_senddata,
|
||||
};
|
||||
|
||||
/**
|
||||
* Issue SCSI command via iSCSI session
|
||||
*
|
||||
* @v iscsi iSCSI session
|
||||
* @v command SCSI command
|
||||
* @ret rc Return status code
|
||||
*/
|
||||
static int iscsi_command ( struct iscsi_session *iscsi,
|
||||
struct scsi_command *command ) {
|
||||
iscsi->command = command;
|
||||
iscsi->status &= ~( ISCSI_STATUS_DONE | ISCSI_STATUS_ERR );
|
||||
|
||||
if ( iscsi->status & ISCSI_STATUS_CONNECTED ) {
|
||||
iscsi_start_command ( iscsi );
|
||||
} else {
|
||||
iscsi->tcp.tcp_op = &iscsi_tcp_operations;
|
||||
tcp_connect ( &iscsi->tcp );
|
||||
}
|
||||
|
||||
while ( ! ( iscsi->status & ISCSI_STATUS_DONE ) ) {
|
||||
step();
|
||||
}
|
||||
|
||||
iscsi->command = NULL;
|
||||
|
||||
return ( ( iscsi->status & ISCSI_STATUS_ERR ) ? -EIO : 0 );
|
||||
}
|
||||
|
||||
/**
|
||||
* Issue SCSI command via iSCSI device
|
||||
*
|
||||
* @v scsi SCSI device
|
||||
* @v command SCSI command
|
||||
* @ret rc Return status code
|
||||
*/
|
||||
static int iscsi_scsi_command ( struct scsi_device *scsi,
|
||||
struct scsi_command *command ) {
|
||||
struct iscsi_device *iscsidev
|
||||
= container_of ( scsi, struct iscsi_device, scsi );
|
||||
|
||||
return iscsi_command ( &iscsidev->iscsi, command );
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialise iSCSI device
|
||||
*
|
||||
* @v iscsidev iSCSI device
|
||||
*/
|
||||
int init_iscsidev ( struct iscsi_device *iscsidev ) {
|
||||
iscsidev->scsi.command = iscsi_scsi_command;
|
||||
iscsidev->scsi.lun = iscsidev->iscsi.lun;
|
||||
return init_scsidev ( &iscsidev->scsi );
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user