diff options
| -rw-r--r-- | src/server/iscsi.c | 693 | ||||
| -rw-r--r-- | src/server/iscsi.h | 767 |
2 files changed, 1339 insertions, 121 deletions
diff --git a/src/server/iscsi.c b/src/server/iscsi.c index 73be352..7dd35b1 100644 --- a/src/server/iscsi.c +++ b/src/server/iscsi.c @@ -1,4 +1,4 @@ - /* +/* * This file is part of the Distributed Network Block Device 3 * * Copyright(c) 2025 Sebastian Vater <sebastian.vater@rz.uni-freiburg.de> @@ -27,6 +27,7 @@ #include <inttypes.h> #include <strings.h> #include <sys/socket.h> +#include <sys/types.h> #include <dnbd3/shared/log.h> #include <dnbd3/shared/sockhelper.h> #include <dnbd3/types.h> @@ -2356,19 +2357,92 @@ static int iscsi_update_bool_key_value_pair(iscsi_hashmap *key_value_pairs, cons } /** - * @brief Enqueues an iSCSI task into it's underlying SCSI management structure. + * @brief Allocates and initializes an iSCSI task structure. * - * This function enqueues an iSCSI task into - * the underlying SCSI task management for - * execution. + * This function also initializes the underlying + * SCSI task structure with the transfer complete + * callback function.\n + * If a parent task is specified, SCSI data + * is copied over from it. * - * @param[in] task Pointer to iSCSI task to be put into - * the SCSI task management, may NOT be NULL, - * so be careful. + * @param[in] conn Pointer to iSCSI connection to associate + * the task with. May NOT be NULL, so take + * caution. + * @param[in] parent Pointer to parent iSCSI task to copy + * over SCSI task data from. + * @param[in] callback Callback function to be invoked + * after data transfer has been completed and + * may be NULL in case no further action is + * required. + * @return Pointer to iSCSI task structure or NULL + * in case of an error (memory exhaustion). + */ +iscsi_task *iscsi_task_create(iscsi_connection *conn, iscsi_task *parent, iscsi_scsi_task_xfer_complete_callback callback) +{ + iscsi_task *task = (iscsi_task *) malloc( sizeof(struct iscsi_task) ); + + if ( task == NULL ) { + logadd( LOG_ERROR, "iscsi_task_create: Out of memory while allocating iSCSI task" ); + + return NULL; + } + + task->parent = parent; + task->conn = conn; + task->pdu = NULL; + task->buf = NULL; + task->pos = 0UL; + task->len = 0UL; + task->flags = 0L; + task->lun_id = 0L; + task->init_task_tag = 0UL; + task->target_xfer_tag = 0UL; + task->des_data_xfer_len = 0UL; + task->r2t_len = 0UL; + task->r2t_sn = 0UL; + task->r2t_next_exp_pos = 0UL; + task->r2t_data_sn = 0UL; + task->r2t_sn_ack = 0UL; + + conn->task_cnt++; + + iscsi_scsi_task_create( &task->scsi_task, callback, iscsi_task_destroy ); + + if ( parent != NULL ) { + parent->scsi_task.ref++; + + task->target_xfer_tag = parent->target_xfer_tag; + task->lun_id = parent->lun_id; + + task->scsi_task.flags = parent->scsi_task.flags; + task->scsi_task.xfer_len = parent->scsi_task.xfer_len; + task->scsi_task.lun = parent->scsi_task.lun; + task->scsi_task.cdb = parent->scsi_task.cdb; + task->scsi_task.target_port = parent->scsi_task.target_port; + task->scsi_task.init_port = parent->scsi_task.init_port; + + if ( (task->scsi_task.flags & ISCSI_SCSI_TASK_FLAGS_XFER_READ) != 0 ) + conn->scsi_data_read_cnt++; + } + + return task; +} + +/** + * @brief Deallocates resources acquired by iscsi_task_create. + * + * This function also frees the embedded SCSI task. + * + * @param[in] task Pointer to iSCSI task to deallocate. May be + * NULL in which case this function does nothing. */ -void iscsi_task_put(iscsi_task *task) +void iscsi_task_destroy(iscsi_task *task) { - iscsi_scsi_task_put( &task->scsi_task ); + if ( task != NULL ) { + iscsi_scsi_task_destroy( &task->scsi_task ); + + free( task ); + } } /** @@ -2415,7 +2489,7 @@ int iscsi_task_find_callback(uint8_t *key, const size_t key_size, uint8_t *value * * @param[in] conn Pointer to iSCSI connection to * search in the active Ready To Transfer tasks - * hash map. + * hash map and may NOT be NULL, so be careful. * @param[in] target_xfer_tag Target Transfer Tag (TTT) * to be searched for. * @return Pointer to found iSCSI task or NULL in @@ -2432,6 +2506,157 @@ static iscsi_task *iscsi_task_find(iscsi_connection *conn, const uint32_t target } /** + * @brief Handles iSCSI task read (incoming) data. + * + * This function handles iSCSI incoming data + * read buffer for both processed and + * unprocessed tasks. + * + * @param[in] conn Pointer to iSCSI connection of which the + * incoming data should be handled, may NOT be + * NULL, so be careful. + * @param[in] task Pointer to iSCSI task for handling + * the incoming data. NULL is NOT allowed here, + * take caution. + * @return 0 on successful incoming transfer handling, + * a negative error code otherwise. + */ +static int iscsi_task_xfer_in(iscsi_connection *conn, iscsi_task *task) +{ + // TODO: Implement function. + + return 0L; +} + +/** + * @brief Creates, initializes and sends an iSCSI task reponse PDU. + * + * This function also receives any remaining + * incoming data in case the task is reading. + * + * @param[in] conn Pointer to iSCSI connection to handle the + * task resnponse for and may NOT be NULL, + * so be careful. + * @param[in] task Pointer to iSSCI task to create the + * response PDU from. NULL is NOT allowed + * here, take caution. + */ +void iscsi_task_response(iscsi_connection *conn, iscsi_task *task) +{ + iscsi_task *primary_task = (task->parent != NULL) ? task->parent : task; + iscsi_pdu *pdu = primary_task->pdu; + iscsi_scsi_cmd_packet *scsi_cmd_pkt = (iscsi_scsi_cmd_packet *) pdu->bhs_pkt; + const uint32_t xfer_len = primary_task->scsi_task.xfer_len; + + if ( (scsi_cmd_pkt->flags_task & ISCSI_SCSI_CMD_FLAGS_TASK_READ) != 0 ) { + const int rc = iscsi_task_xfer_in( conn, task ); + + if ( (rc < 0) || (primary_task->pos != xfer_len) ) + return; + } + + iscsi_pdu *response_pdu = iscsi_connection_pdu_create( conn ); + + if ( response_pdu == NULL ) { + logadd( LOG_ERROR, "iscsi_task_response: Out of memory while allocating iSCSI SCSI response PDU" ); + + return; + } + + iscsi_scsi_response_packet *scsi_response_pkt; + uint32_t ds_len; + + if ( task->scsi_task.sense_data_len != 0 ) { + ds_len = (task->scsi_task.sense_data_len + offsetof(struct iscsi_scsi_ds_cmd_data, sense_data)); + scsi_response_pkt = (iscsi_scsi_response_packet *) iscsi_append_ds_packet( response_pdu->bhs_pkt, conn->header_digest, ds_len, conn->data_digest ); + + if ( scsi_response_pkt == NULL ) { + logadd( LOG_ERROR, "iscsi_task_response: Out of memory while allocating iSCSI SCSI response packet data" ); + + iscsi_connection_pdu_destroy( response_pdu ); + + return; + } + + response_pdu->bhs_pkt = (iscsi_bhs_packet *) scsi_response_pkt; + + if ( conn->header_digest != 0 ) { + response_pdu->header_digest = (iscsi_header_digest *) (((iscsi_bhs_packet *) scsi_response_pkt) + 1); + response_pdu->header_digest_size = conn->header_digest; + } + + response_pdu->ds_cmd_data = (iscsi_scsi_ds_cmd_data *) (((uint8_t *) scsi_response_pkt) + sizeof(struct iscsi_bhs_packet) + conn->header_digest); + response_pdu->ds_len = ds_len; + + if ( conn->data_digest != 0 ) { + response_pdu->data_digest = (iscsi_data_digest *) (((uint8_t *) response_pdu->ds_cmd_data) + iscsi_align(ds_len, ISCSI_ALIGN_SIZE)); + response_pdu->data_digest_size = conn->data_digest; + } + + iscsi_scsi_ds_cmd_data *ds_cmd_data_pkt = response_pdu->ds_cmd_data; + + iscsi_put_be16( (uint8_t *) &ds_cmd_data_pkt->len, task->scsi_task.sense_data_len ); + memcpy( ds_cmd_data_pkt->sense_data, task->scsi_task.sense_data, task->scsi_task.sense_data_len ); + + iscsi_put_be24( (uint8_t *) &scsi_response_pkt->ds_len, ds_len ); + } else { + ds_len = 0uL; + + if ( conn->header_digest != 0 ) { + scsi_response_pkt = (iscsi_r2t_packet *) iscsi_append_header_digest_packet( response_pdu->bhs_pkt, conn->header_digest ); + + if ( scsi_response_pkt == NULL ) { + logadd( LOG_ERROR, "iscsi_task_response: Out of memory while allocating iSCSI SCSI response packet data" ); + + iscsi_connection_pdu_destroy( response_pdu ); + + return; + } + + response_pdu->bhs_pkt = (iscsi_bhs_packet *) scsi_response_pkt; + response_pdu->header_digest = (iscsi_header_digest *) (((iscsi_bhs_packet *) scsi_response_pkt) + 1); + response_pdu->header_digest_size = conn->header_digest; + } else { + scsi_response_pkt = (iscsi_scsi_response_packet *) response_pdu->bhs_pkt; + } + } + + response_pdu->task = task; + task->scsi_task.ref++; + + scsi_response_pkt->opcode = ISCSI_OPCODE_SERVER_SCSI_RESPONSE; + scsi_response_pkt->flags = -0x80; + + const uint32_t pos = primary_task->scsi_task.pos; + + if ( (xfer_len != 0) && (task->scsi_task.status == ISCSI_SCSI_STATUS_GOOD) ) { + if ( pos < xfer_len ) { + const uint32_t res_cnt = (xfer_len - pos); + + scsi_response_pkt->flags |= ISCSI_SCSI_RESPONSE_FLAGS_RES_UNDERFLOW; + iscsi_put_be32( (uint8_t *) &scsi_response_pkt->res_cnt, res_cnt ); + } else if ( pos > xfer_len ) { + const uint32_t res_cnt = (pos - xfer_len); + + scsi_response_pkt->flags |= ISCSI_SCSI_RESPONSE_FLAGS_RES_OVERFLOW; + iscsi_put_be32( (uint8_t *) &scsi_response_pkt->res_cnt, res_cnt ); + } + } + + scsi_response_pkt->status = task->scsi_task.status; + iscsi_put_be32( (uint8_t *) &scsi_response_pkt->init_task_tag, task->init_task_tag ); + iscsi_put_be32( (uint8_t *) &scsi_response_pkt->stat_sn, conn->stat_sn++ ); + + if ( (scsi_cmd_pkt->opcode & ISCSI_OPCODE_FLAGS_IMMEDIATE) == 0 ) + conn->session->max_cmd_sn++; + + iscsi_put_be32( (uint8_t *) &scsi_response_pkt->exp_cmd_sn, conn->session->exp_cmd_sn ); + iscsi_put_be32( (uint8_t *) &scsi_response_pkt->max_cmd_sn, conn->session->max_cmd_sn ); + + iscsi_connection_pdu_write( conn, response_pdu, NULL, NULL ); +} + +/** * @brief Creates and initializes an iSCSI portal group. * * Specified tag and flags are used for portal group @@ -2499,6 +2724,7 @@ int iscsi_portal_destroy_callback(uint8_t *key, const size_t key_size, uint8_t * * * This function frees the associated hash map containing the * poptals and the structure itself. + * * @param[in] portal_group Pointer to iSCSI portal group to deallocate. * May be NULL in which case this function does nothing. */ @@ -2645,20 +2871,185 @@ void iscsi_portal_destroy(iscsi_portal *portal) } /** - * @brief Enqueues a SCSI task for execution. + * @brief Allocates and initializes a SCSI task. * - * This function decreases the reference - * counter and after execution is done, - * the associated I/O resources will be - * freed. + * THis function assocates the callback + * functions to the SCSI task and sets + * the reference count to 1. * - * @param[in] scsi_task Pointer to SCSI task structure to - * enqueue. NULL is NOT allowed here, so - * take caution. + * @param[in] scsi_task Pointer to SCSI task. This + * may NOT be NULL, so be careful. + * @param[in] xfer_complete_callback Pointer to transfer completed callback + * function. + * @param[in] destroy_callback Pointer to SCSI task destruction + * callback function. + */ +void iscsi_scsi_task_create(iscsi_scsi_task *scsi_task, iscsi_scsi_task_xfer_complete_callback xfer_complete_callback, iscsi_scsi_task_destroy_callback destroy_callback) +{ + scsi_task->lun = NULL; + scsi_task->target_port = NULL; + scsi_task->init_port = NULL; + scsi_task->cdb = NULL; + scsi_task->xfer_complete_callback = xfer_complete_callback; + scsi_task->destroy_callback = destroy_callback; + scsi_task->sense_data = NULL; + scsi_task->buf = NULL; + scsi_task->pos = 0UL; + scsi_task->len = 0UL; + scsi_task->flags = 0L; + scsi_task->ref = 1UL; + scsi_task->xfer_len = 0UL; + scsi_task->sense_data_len = 0U; + scsi_task->status = ISCSI_SCSI_STATUS_GOOD; + scsi_task->task_mgmt_func = ISCSI_TASK_MGMT_FUNC_REQ_FUNC_ABORT_TASK; + scsi_task->task_mgmt_response = ISCSI_TASK_MGMT_FUNC_RESPONSE_FUNC_COMPLETE; +} + +/** + * @brief Deallocates all resources acquired iscsi_scsi_task_create. + * + * This function also calls the task destruction + * callback function if the reference count + * becomes zero. + * + * @param[in] scsi_task SCSI task to deallocate. This may + * be NULL in which case nothing happens. + */ +void iscsi_scsi_task_destroy(iscsi_scsi_task *scsi_task) +{ + if ( scsi_task != NULL ) { + if ( --scsi_task->ref == 0 ) + scsi_task->destroy_callback( scsi_task ); + } +} + +/** + * @brief Callback function when an iSCSI SCSI task completed the data transfer. + * + * This function post-processes a task upon + * finish of data transfer. + * + * @param[in] scsi_task Pointer to iSCSI SCSI task which finished + * the data transfer and may NOT be NULL, + * so be careful. + */ +void iscsi_scsi_task_xfer_complete(iscsi_scsi_task *scsi_task) +{ + // TODO: Implement function. +} + +/** + * @brief Allocates, if necessary and initializes SCSI sense data for check condition status code. + * + * This function is invoked whenever additional + * SCSI sense data for check condition status + * code is required for sending to the + * initiator. + * + * @param[in] scsi_task Pointer to iSCSI SCSI task to allocate + * and assign the SCSI check condition status + * code sense data for. May NOT be NULL, so + * be careful. + * @param[in] sense_key Sense Key (SK). + * @param[in] asc Additional Sense Code (ASC). + * @param[in] ascq Additional Sense Code Qualifier (ASCQ). + */ +void iscsi_scsi_task_sense_data_check_cond_build(iscsi_scsi_task *scsi_task, const uint8_t sense_key, const uint8_t asc, const uint8_t ascq) +{ + iscsi_scsi_sense_data_check_cond_packet *sense_data = (iscsi_scsi_sense_data_check_cond_packet *) scsi_task->sense_data; + + if ( sense_data == NULL ) { + sense_data = malloc( sizeof(struct iscsi_scsi_sense_data_check_cond_packet) ); + + if ( sense_data == NULL ) { + logadd( LOG_ERROR, "iscsi_scsi_task_sense_data_build: Out of memory allocating iSCSI SCSI conidtion check status code sense data" ); + + return; + } + + scsi_task->sense_data = sense_data; + } + + sense_data->sense_data.response_code = (ISCSI_SCSI_SENSE_DATA_RESPONSE_CODE_CURRENT_FMT | ISCSI_SCSI_SENSE_DATA_RESPONSE_CODE_VALID); + sense_data->sense_data.reserved = 0U; + sense_data->sense_data.sense_key_flags = (sense_key & ISCSI_SCSI_SENSE_DATA_SENSE_KEY_MASK); + sense_data->sense_data.info = 0UL; // Zero does not require endianess conversion + sense_data->sense_data.add_len = (sizeof(struct iscsi_scsi_sense_data_check_cond_packet) - sizeof(struct iscsi_scsi_sense_data_packet)); + + sense_data->cmd_spec_info = 0UL; // Zero does not require endianess conversion + sense_data->asc = asc; + sense_data->ascq = ascq; + sense_data->field_rep_unit_code = 0U; + sense_data->sense_key_spec_flags = 0U; + sense_data->sense_key_spec = 0U; // Zero does not require endianess conversion + + scsi_task->sense_data_len = sizeof(struct iscsi_scsi_sense_data_check_cond_packet); +} + +/** + * @brief Sets an iSCSI SCSI task status code with optional additional details. + * + * Sense Key (SK), Additional Sense Code (ASC) + * and Additional Sense Code Qualifier (ASCQ) + * are only generated on check condition SCSI + * status code. + * + * @param[in] scsi_task Pointer to iSCSI SCSI task to set the + * SCSI status and additional details for. May + * NOT be NULL, so be careful. + * @param[in] status SCSI status code to be set. + * @param[in] sense_key Sense Key (SK). + * @param[in] asc Additional Sense Code (ASC). + * @param[in] ascq Additional Sense Code Qualifier (ASCQ). + */ +static void iscsi_scsi_task_status_set(iscsi_scsi_task *scsi_task, const uint8_t status, const uint8_t sense_key, const uint8_t asc, const uint8_t ascq) +{ + if ( status == ISCSI_SCSI_STATUS_CHECK_COND ) + iscsi_scsi_task_sense_data_check_cond_build( scsi_task, sense_key, asc, ascq ); + + scsi_task->status = status; +} + +/** + * @brief Processes a iSCSI SCSI task with no LUN identifier. + * + * This function only generates a SCSI response + * if the SCSI command is INQUIRY, otherwise + * a SCSI error will be generated as specified + * by the SCSI standard. + * + * @param[in] scsi_task Pointer to iSCSI SCSI task to process + * the task with no LUN identifier for. May NOT + * be NULL, so be careful. */ -void iscsi_scsi_task_put(iscsi_scsi_task *scsi_task) +void iscsi_scsi_task_lun_process_none(iscsi_scsi_task *scsi_task) { - // TODO: Implement SCSI function. + iscsi_scsi_std_inquiry_data_packet std_inquiry_data_pkt; + + scsi_task->len = scsi_task->xfer_len; + + if ( scsi_task->cdb->opcode == ISCSI_SCSI_OPCODE_INQUIRY ) { + uint len = sizeof(struct iscsi_scsi_std_inquiry_data_packet); + + memset( &std_inquiry_data_pkt, 0, len ); + + std_inquiry_data_pkt.peripheral_type_id = ((ISCSI_SCSI_DATA_PERIPHERAL_TYPE_UNKNOWN << ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FIRST_BIT) | (ISCSI_SCSI_DATA_PERIPHERAL_ID_NEVER << ISCSI_SCSI_DATA_PERIPHERAL_ID_FIRST_BIT)); + std_inquiry_data_pkt.add_len = (uint8_t) (len - sizeof(struct iscsi_scsi_data_packet)); + + const uint alloc_len = iscsi_get_be16(scsi_task->cdb->alloc_len); + + if ( len > alloc_len ) + len = alloc_len; + + memcpy( scsi_task->buf, &std_inquiry_data_pkt, len ); + + scsi_task->pos = len; + scsi_task->status = ISCSI_SCSI_STATUS_GOOD; + } else { + iscsi_scsi_task_status_set( scsi_task, ISCSI_SCSI_STATUS_CHECK_COND, ISCSI_SCSI_SENSE_KEY_ILLEGAL_REQ, ISCSI_SCSI_ASC_LU_NOT_SUPPORTED, ISCSI_SCSI_ASCQ_CAUSE_NOT_REPORTABLE ); + + scsi_task->pos = 0UL; + } } /** @@ -3554,7 +3945,8 @@ iscsi_session *iscsi_session_create(iscsi_connection *conn, iscsi_target_node *t * @brief Deallocates all resources acquired by iscsi_session_create. * * This function also frees the associated key and value pairs, - * the attached connections as well as frees the initator port. + * the attached connections as well as frees the initiator + * port. * * @param[in] session Pointer to iSCSI session to be freed. * May be NULL in which case this function does nothing at all. @@ -3580,10 +3972,10 @@ void iscsi_session_destroy(iscsi_session *session) session->connections = NULL; } - if ( session->initiator_port != NULL ) { - iscsi_port_destroy( session->initiator_port ); + if ( session->init_port != NULL ) { + iscsi_port_destroy( session->init_port ); - session->initiator_port = NULL; + session->init_port = NULL; } free( session ); // TODO: Check if potential reusage of session makes sense. @@ -3718,8 +4110,22 @@ iscsi_connection *iscsi_connection_create(iscsi_portal *portal, const int sock) conn->r2t_tasks_active = iscsi_hashmap_create( 0UL ); if ( conn->r2t_tasks_active == NULL ) { - logadd( LOG_ERROR, "iscsi_create_connection: Out of memory while allocating iSCSI active Ready To Transfer task hash map" ); + logadd( LOG_ERROR, "iscsi_create_connection: Out of memory while allocating iSCSI active Ready To Transfer (R2T) task hash map" ); + + iscsi_hashmap_destroy( conn->pdu_snack ); + iscsi_hashmap_iterate( conn->key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL ); + iscsi_hashmap_destroy( conn->key_value_pairs ); + free( conn ); + + return NULL; + } + + conn->r2t_tasks_queue = iscsi_hashmap_create( 0UL ); + if ( conn->r2t_tasks_queue == NULL ) { + logadd( LOG_ERROR, "iscsi_create_connection: Out of memory while allocating iSCSI enqueued Ready To Transfer (R2T) task hash map" ); + + iscsi_hashmap_destroy( conn->r2t_tasks_active ); iscsi_hashmap_destroy( conn->pdu_snack ); iscsi_hashmap_iterate( conn->key_value_pairs, iscsi_hashmap_key_destroy_value_callback, NULL ); iscsi_hashmap_destroy( conn->key_value_pairs ); @@ -3729,6 +4135,8 @@ iscsi_connection *iscsi_connection_create(iscsi_portal *portal, const int sock) } conn->target_send_total_size = 0UL; + conn->scsi_data_read_cnt = 0UL; + conn->task_cnt = 0UL; conn->header_digest = 0L; conn->data_digest = 0L; conn->id = 0L; @@ -3796,6 +4204,13 @@ int iscsi_connection_destroy_callback(uint8_t *key, const size_t key_size, uint8 void iscsi_connection_destroy(iscsi_connection *conn) { if ( conn != NULL ) { + if ( conn->r2t_tasks_queue != NULL ) { + iscsi_hashmap_iterate( conn->r2t_tasks_queue, iscsi_hashmap_key_destroy_callback, NULL ); + iscsi_hashmap_destroy( conn->r2t_tasks_queue ); + + conn->r2t_tasks_queue = NULL; + } + if ( conn->r2t_tasks_active != NULL ) { iscsi_hashmap_iterate( conn->r2t_tasks_active, iscsi_hashmap_key_destroy_callback, NULL ); iscsi_hashmap_destroy( conn->r2t_tasks_active ); @@ -4632,7 +5047,7 @@ static int iscsi_connection_update_key_value_pairs(iscsi_connection *conn) * be sent via TCP/IP. * @param[in] key_value_pairs Pointer to hash map of key and value pairs * to be used for login response storage. - * @paran[in] callback Pointer to post processing callback function + * @param[in] callback Pointer to post processing callback function * after sending the TCP/IP packet. */ static void iscsi_connection_pdu_login_response(iscsi_connection *conn, iscsi_pdu *login_response_pdu, iscsi_hashmap *key_value_pairs, iscsi_connection_xfer_complete_callback callback) @@ -4735,7 +5150,7 @@ static int iscsi_login_response_init(iscsi_pdu *login_response_pdu, const iscsi_ } login_response_pdu->bhs_pkt = (iscsi_bhs_packet *) login_response_pkt; - login_response_pdu->ds_cmd_data = (iscsi_ds_cmd_data *) (((uint8_t *) login_response_pkt) + sizeof(struct iscsi_bhs_packet) + pdu->header_digest_size); + login_response_pdu->ds_cmd_data = (iscsi_scsi_ds_cmd_data *) (((uint8_t *) login_response_pkt) + sizeof(struct iscsi_bhs_packet) + pdu->header_digest_size); login_response_pdu->len = ISCSI_DEFAULT_RECV_DS_LEN; login_response_pkt->flags |= (int8_t) (login_req_pkt->flags & (ISCSI_LOGIN_REQ_FLAGS_TRANSIT | ISCSI_LOGIN_REQ_FLAGS_CONTINUE | ISCSI_LOGIN_REQ_FLAGS_CURRENT_STAGE_MASK)); @@ -4844,8 +5259,8 @@ static inline uint64_t iscsi_connection_get_isid(const iscsi_isid *isid) * @param[in] response_pdu Pointer to response PDU to initialize the * port from, NULL is NOT allowed here, so be careful. * @param[in] key_value_pairs Pointer to the hash map containing the key - * and value pair for the initator name. May NOT be NULL, - * so take caution. + * and value pair for the initiator name. May NOT be + * NULL, so take caution. * @param[out] init_port_name Pointer to store the full qualified name * of the initiator port and may NOT be NULL, so be careful. * @return 0 in case the port could be initialized @@ -5066,7 +5481,7 @@ static uint16_t iscsi_session_append(iscsi_connection *conn, const uint8_t *init { iscsi_session *session = iscsi_session_get_by_tsih( tsih ); - if ( (session == NULL) || (conn->pg_tag != session->tag) || (strcasecmp( (char *) init_port_name, (char *) iscsi_port_get_name( session->initiator_port ) ) != 0) || (conn->target != session->target) ) + if ( (session == NULL) || (conn->pg_tag != session->tag) || (strcasecmp( (char *) init_port_name, (char *) iscsi_port_get_name( session->init_port ) ) != 0) || (conn->target != session->target) ) return (ISCSI_LOGIN_RESPONSE_STATUS_CLASS_CLIENT_ERR << 8U) | ISCSI_LOGIN_RESPONSE_STATUS_DETAILS_CLIENT_ERR_NO_SESSION_SPANNING; if ( iscsi_hashmap_size( session->connections ) >= session->max_conns ) @@ -5179,6 +5594,7 @@ iscsi_pdu *iscsi_connection_pdu_create(iscsi_connection *conn) pdu->ds_cmd_data = NULL; pdu->data_digest = NULL; pdu->task = NULL; + pdu->conn = conn; pdu->xfer_complete_callback = NULL; pdu->xfer_complete_user_data = NULL; pdu->flags = 0L; @@ -5192,7 +5608,7 @@ iscsi_pdu *iscsi_connection_pdu_create(iscsi_connection *conn) pdu->ds_len = 0UL; pdu->pos = 0UL; pdu->len = 0UL; - pdu->conn = conn; + pdu->task_ref_cnt = 0UL; pdu->cmd_sn = 0UL; return pdu; @@ -5234,7 +5650,7 @@ void iscsi_connection_pdu_free(iscsi_connection *conn, iscsi_pdu *pdu) pdu->xfer_complete_callback = NULL; if ( pdu->task != NULL ) - iscsi_task_put( pdu->task ); + iscsi_task_destroy( pdu->task ); iscsi_connection_pdu_destroy( pdu ); @@ -5414,7 +5830,7 @@ static int iscsi_connection_handle_reject(iscsi_connection *conn, iscsi_pdu *pdu response_pdu->header_digest_size = conn->header_digest; } - response_pdu->ds_cmd_data = (iscsi_ds_cmd_data *) (((uint8_t *) reject_pkt) + sizeof(struct iscsi_bhs_packet) + conn->header_digest); + response_pdu->ds_cmd_data = (iscsi_scsi_ds_cmd_data *) (((uint8_t *) reject_pkt) + sizeof(struct iscsi_bhs_packet) + conn->header_digest); response_pdu->ds_len = ds_len; if ( conn->data_digest != 0 ) { @@ -5570,7 +5986,7 @@ static int iscsi_connection_pdu_header_handle_nop_out(iscsi_connection *conn, is if ( (init_task_tag == 0xFFFFFFFFUL) && (nop_out_pkt->opcode & ISCSI_OPCODE_FLAGS_IMMEDIATE) == 0 ) return ISCSI_CONNECT_PDU_READ_ERR_FATAL; - return 0L; + return ISCSI_CONNECT_PDU_READ_OK; } /** @@ -5590,9 +6006,91 @@ static int iscsi_connection_pdu_header_handle_nop_out(iscsi_connection *conn, is */ static int iscsi_connection_pdu_header_handle_scsi_cmd(iscsi_connection *conn, iscsi_pdu *pdu) { - // TODO: Implement opcode. + if ( conn->session->type != ISCSI_SESSION_TYPE_NORMAL ) + return ISCSI_CONNECT_PDU_READ_ERR_FATAL; - return 0; + iscsi_scsi_cmd_packet *scsi_cmd_pkt = (iscsi_scsi_cmd_packet *) pdu->bhs_pkt; + + if ( ((scsi_cmd_pkt->flags_task & ISCSI_SCSI_CMD_FLAGS_TASK_READ) != 0) && ((scsi_cmd_pkt->flags_task & ISCSI_SCSI_CMD_FLAGS_TASK_WRITE) != 0) ) // Bidirectional transfer is not supported + return ISCSI_CONNECT_PDU_READ_ERR_FATAL; + + iscsi_task *task = iscsi_task_create( conn, NULL, iscsi_scsi_task_xfer_complete ); + + if ( task == NULL ) + return ISCSI_CONNECT_PDU_READ_ERR_FATAL; + + uint32_t exp_xfer_len = iscsi_get_be32(scsi_cmd_pkt->exp_xfer_len); + + task->scsi_task.buf = (uint8_t *) pdu->ds_cmd_data; + task->scsi_task.len = (uint) (((uint8_t *) pdu->ds_cmd_data) - ((uint8_t *) pdu->bhs_pkt)); + task->scsi_task.cdb = &scsi_cmd_pkt->scsi_cdb; + task->scsi_task.xfer_len = exp_xfer_len; + task->scsi_task.target_port = conn->target_port; + task->scsi_task.init_port = conn->init_port; + task->init_task_tag = iscsi_get_be32(scsi_cmd_pkt->init_task_tag); + task->pdu = pdu; + + const uint64_t lun = iscsi_get_be64(scsi_cmd_pkt->lun); + const int lun_id = iscsi_lun_get_from_iscsi( lun ); + + task->scsi_task.lun = iscsi_device_find_lun( conn->device, lun_id ); + + if ( task->scsi_task.lun == NULL ) { + iscsi_scsi_task_lun_process_none( &task->scsi_task ); + iscsi_scsi_task_xfer_complete( &task->scsi_task ); + + return ISCSI_CONNECT_PDU_READ_OK; + } + + if ( ((scsi_cmd_pkt->flags_task & ISCSI_SCSI_CMD_FLAGS_TASK_READ) == 0) && ((scsi_cmd_pkt->flags_task & ISCSI_SCSI_CMD_FLAGS_TASK_WRITE) == 0) && (exp_xfer_len > 0) ) { + iscsi_task_destroy( task ); + + return iscsi_connection_handle_reject( conn, pdu, ISCSI_REJECT_REASON_INVALID_PDU_FIELD ); + } + + if ( (scsi_cmd_pkt->flags_task & ISCSI_SCSI_CMD_FLAGS_TASK_READ) != 0 ) + task->flags |= ISCSI_SCSI_TASK_FLAGS_XFER_READ; + + if ( (scsi_cmd_pkt->flags_task & ISCSI_SCSI_CMD_FLAGS_TASK_WRITE) != 0 ) { + task->flags |= ISCSI_SCSI_TASK_FLAGS_XFER_WRITE; + + if ( (conn->session->err_recovery_level > 0) && (iscsi_r2t_find_pdu_bhs( conn, pdu ) != NULL) ) { + iscsi_task_response( conn, task ); + iscsi_task_destroy( task ); + + return ISCSI_CONNECT_PDU_READ_OK; + } + + if ( pdu->ds_len > (uint) (sizeof(struct iscsi_bhs_packet) + ISCSI_MAX_AHS_SIZE + conn->header_digest + ISCSI_SESSION_DEFAULT_FIRST_BURST_LEN + conn->data_digest) ) { + iscsi_task_destroy( task ); + + return iscsi_connection_handle_reject( conn, pdu, ISCSI_REJECT_REASON_PROTOCOL_ERR ); + } + + if ( pdu->ds_len > exp_xfer_len ) { + iscsi_task_destroy( task ); + + return iscsi_connection_handle_reject( conn, pdu, ISCSI_REJECT_REASON_PROTOCOL_ERR ); + } + + if ( (((conn->session->flags & ISCSI_SESSION_FLAGS_IMMEDIATE_DATA) == 0) && (pdu->ds_len > 0)) || (pdu->ds_len > conn->session->first_burst_len) ) { + iscsi_task_destroy( task ); + + return iscsi_connection_handle_reject( conn, pdu, ISCSI_REJECT_REASON_PROTOCOL_ERR ); + } + + if ( ((scsi_cmd_pkt->flags_task & ISCSI_SCSI_CMD_FLAGS_FINAL) != 0) && (pdu->ds_len < exp_xfer_len) ) { + if ( exp_xfer_len > ISCSI_DEFAULT_MAX_RECV_DS_LEN ) + exp_xfer_len = ISCSI_DEFAULT_MAX_RECV_DS_LEN; + + pdu->len = exp_xfer_len; + } + } + + pdu->task = task; + pdu->task_ref_cnt++; + + return ISCSI_CONNECT_PDU_READ_OK; } /** @@ -5657,6 +6155,74 @@ static int iscsi_connection_pdu_header_handle_text_req(iscsi_connection *conn, i } /** + * @brief Finds an iSCSI PDU by Basic Header Segment (BHS) in either the Ready To Transfer (R2T) active and queued task hash map. + * + * Callback function for each element while iterating + * either through the iSCSI active or queued Ready To + * Transfer (R2T) task hash map. + * + * @param[in] key Pointer to zero padded key. NULL is + * an invalid pointer here, so be careful. + * @param[in] key_size Number of bytes for the key, MUST + * be a multiple of 8 bytes which is NOT checked, so + * be careful. + * @param[in] value Value of the key, NULL creates an + * empty key assignment. + * @param[in,out] user_data Pointer to a data structure + * containing the iSCSI PDU and the Basic Header + * Segment (BHS) to be searched for and may NOT + * be NULL, so be careful. + * @retval -1 The PDU has been found and stored + * in the result structure. Therefore, no further + * searching is needed. + * @retval 0 The PDU has not been found yet. + */ +int iscsi_r2t_find_pdu_bhs_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data) +{ + iscsi_r2t_find_bhs *pdu_find_bhs = (iscsi_r2t_find_bhs *) user_data; + iscsi_task *task = (iscsi_task *) value; + + if ( memcmp( task->pdu->bhs_pkt, pdu_find_bhs->bhs_pkt, sizeof(struct iscsi_bhs_packet) ) != 0 ) + return 0L; + + pdu_find_bhs->pdu = task->pdu; + + return -1L; +} + +/** + * @brief Searches an iSCSI PDU by Basic Header Segment (BHS) in the Ready To Transfer (R2T) active and queued task hash map. + * + * This function searches for an iSCSI PDU by + * iterating through the iSCSI connection active + * and queued Ready To Transfer tasks hash map. + * + * @param[in] conn Pointer to iSCSI connection to + * search in the active and queued Ready To + * Transfer tasks hash map. May NOT be NULL, so + * be careful. + * @param[in] pdu Pointer to iSCSI PDU of which + * the Basic Header Segment (BHS) should be + * searched for. NULL is NOT allowed here, so + * take caution. + * @return Pointer to found iSCSI PDU or NULL in + * case neither an iSCSI active nor enqueued + * Ready To Transfer (R2T) task has a matching + * Basic Header Segment (BHS). + */ +iscsi_pdu *iscsi_r2t_find_pdu_bhs(iscsi_connection *conn, iscsi_pdu *pdu) +{ + iscsi_r2t_find_bhs pdu_find_bhs = {NULL, pdu->bhs_pkt}; + + const int rc = iscsi_hashmap_iterate( conn->r2t_tasks_active, iscsi_r2t_find_pdu_bhs_callback, (uint8_t *) &pdu_find_bhs ); + + if ( rc == 0 ) + iscsi_hashmap_iterate( conn->r2t_tasks_queue, iscsi_r2t_find_pdu_bhs_callback, (uint8_t *) &pdu_find_bhs ); + + return pdu_find_bhs.pdu; +} + +/** * @brief Sends an iSCSI Ready To Transfer Sequence Number (R2TSN) packet to the initiator. * * This function allocates and initializes a @@ -5774,20 +6340,29 @@ int iscsi_r2t_remove_pdu_from_snack_list_callback(uint8_t *key, const size_t key } /** - * @brief Searches an iSCSI task by Target Transfer Tag (TTT). + * @brief Searches an iSCSI PDU task by Ready To Transfer Sequence Number (R2TSN) and removes it from PDU SNACK hash map. * - * This function searches for an iSCSI task by - * iterating through the iSCSI connection active - * Ready To Transfer tasks hash map. + * This function searches for an iSCSI PDU task + * by iterating through the iSCSI connection + * Sequence Number Acknowledgement S(NACK) + * and matches the Ready To Transfer Sequence + * Number (R2TSN).\n + * If found, the PDU will be removed from the + * PDU SNACK list. * * @param[in] conn Pointer to iSCSI connection to - * search in the active Ready To Transfer tasks - * hash map. - * @param[in] target_xfer_tag Target Transfer Tag (TTT) - * to be searched for. - * @return Pointer to found iSCSI task or NULL in - * case no iSCSI task has a matching Target - * Transfer Tag (TTT). + * search in the Sequence Number + * Acknowledgement (SNACK) hash map. May NOT be + * NULL, so be careful. + * @param[in] task Pointer to iSCSI task to search + * for in the Sequence Number Acknowledgement + * (SNACK) hash map. NULL is not allowed here, + * take caution. + * @param[in] r2t_sn Ready To Transfer Sequence Number + * (R2TSN) to be searched for. + * @return Pointer to found iSCSI PDU or NULL in + * case no iSCSI PDU has a matching Ready To Transfer + * Sequence Number (R2TSN). */ static iscsi_pdu *iscsi_r2t_remove_pdu_from_snack_list(iscsi_connection *conn, iscsi_task *task, const uint32_t r2t_sn) { @@ -5943,7 +6518,7 @@ static int iscsi_connection_pdu_header_handle_scsi_data_out(iscsi_connection *co // TODO: Implement dif ctx stuff. if ( task->buf != NULL ) { - pdu->ds_cmd_data = (iscsi_ds_cmd_data *) (task->buf + task->len); + pdu->ds_cmd_data = (iscsi_scsi_ds_cmd_data *) (task->buf + task->len); pdu->ds_len = ISCSI_DEFAULT_MAX_RECV_DS_LEN; } else { // TODO: Implement dif ctx stuff. @@ -6203,7 +6778,7 @@ static int iscsi_connection_pdu_data_handle_nop_out(iscsi_connection *conn, iscs response_pdu->header_digest_size = conn->header_digest; } - response_pdu->ds_cmd_data = (iscsi_ds_cmd_data *) (((uint8_t *) nop_in_pkt) + sizeof(struct iscsi_bhs_packet) + conn->header_digest); + response_pdu->ds_cmd_data = (iscsi_scsi_ds_cmd_data *) (((uint8_t *) nop_in_pkt) + sizeof(struct iscsi_bhs_packet) + conn->header_digest); response_pdu->ds_len = ds_len; if ( conn->data_digest != 0 ) { @@ -6470,11 +7045,11 @@ static int iscsi_connection_login_set_info(iscsi_connection *conn, iscsi_pdu *lo return ISCSI_CONNECT_PDU_READ_ERR_LOGIN_RESPONSE; } - conn->session->initiator_port = init_port; - conn->stat_sn = iscsi_get_be32(login_response_pkt->stat_sn); - conn->session->isid = isid; + conn->session->init_port = init_port; + conn->stat_sn = iscsi_get_be32(login_response_pkt->stat_sn); + conn->session->isid = isid; - const int rc = iscsi_port_transport_id_set( conn->session->initiator_port, conn->init_name, isid ); + const int rc = iscsi_port_transport_id_set( conn->session->init_port, conn->init_name, isid ); if ( rc < 0 ) { iscsi_session_destroy( conn->session ); @@ -6490,7 +7065,7 @@ static int iscsi_connection_login_set_info(iscsi_connection *conn, iscsi_pdu *lo conn->session->max_cmd_sn = login_response_pdu->cmd_sn + conn->session->queue_depth - 1; } - conn->init_port = conn->session->initiator_port; + conn->init_port = conn->session->init_port; return ISCSI_CONNECT_PDU_READ_OK; } @@ -7031,7 +7606,7 @@ static int iscsi_connection_pdu_data_handle_text_req(iscsi_connection *conn, isc response_pdu->header_digest_size = conn->header_digest; } - response_pdu->ds_cmd_data = (iscsi_ds_cmd_data *) (((uint8_t *) text_response_pkt) + sizeof(struct iscsi_bhs_packet) + conn->header_digest); + response_pdu->ds_cmd_data = (iscsi_scsi_ds_cmd_data *) (((uint8_t *) text_response_pkt) + sizeof(struct iscsi_bhs_packet) + conn->header_digest); response_pdu->ds_len = ds_len; if ( conn->data_digest != 0 ) { @@ -7260,10 +7835,10 @@ int iscsi_connection_pdu_data_read(iscsi_connection *conn, iscsi_pdu *pdu) if ( buf == NULL ) return ISCSI_CONNECT_PDU_READ_ERR_FATAL; - pdu->bhs_pkt = (iscsi_bhs_packet *) buf; - pdu->ahs_pkt = (iscsi_ahs_packet *) (((iscsi_bhs_packet *) pdu->bhs_pkt) + 1); + pdu->bhs_pkt = (iscsi_bhs_packet *) buf; + pdu->ahs_pkt = (iscsi_ahs_packet *) (((iscsi_bhs_packet *) pdu->bhs_pkt) + 1); pdu->header_digest = (iscsi_header_digest *) (((uint8_t *) pdu->bhs_pkt) + sizeof(struct iscsi_bhs_packet) + pdu->ahs_len); - pdu->ds_cmd_data = (iscsi_ds_cmd_data *) (((uint8_t *) pdu->bhs_pkt) + sizeof(struct iscsi_bhs_packet) + pdu->ahs_len + conn->header_digest); + pdu->ds_cmd_data = (iscsi_scsi_ds_cmd_data *) (((uint8_t *) pdu->bhs_pkt) + sizeof(struct iscsi_bhs_packet) + pdu->ahs_len + conn->header_digest); if ( conn->data_digest != 0 ) pdu->data_digest = (iscsi_data_digest *) (((uint8_t *) pdu->bhs_pkt) + sizeof(struct iscsi_bhs_packet) + pdu->ahs_len + conn->header_digest + ds_len); diff --git a/src/server/iscsi.h b/src/server/iscsi.h index 67c1655..4af7bb8 100644 --- a/src/server/iscsi.h +++ b/src/server/iscsi.h @@ -33,6 +33,12 @@ #define DNBD3_ISCSI_H_ #include <inttypes.h> +#include <stdio.h> +#include <sys/types.h> +#include <dnbd3/types.h> + +#include "globals.h" +#include "image.h" #if defined(__BIG_ENDIAN__) || (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && __BYTE_ORDER == __BIG_ENDIAN) || (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) #define iscsi_get_be16(x) (x) @@ -463,16 +469,6 @@ typedef struct __attribute__((packed)) iscsi_ahs_packet { uint8_t data[0]; } iscsi_ahs_packet; -/** - * @brief iSCSI CDB packet data structure. - * - * There are 16 bytes in the CDB field to accommodate the commonly used - * CDBs. Whenever the CDB is larger than 16 bytes, an Extended CDB AHS - * MUST be used to contain the CDB spillover. - */ -typedef struct __attribute__((packed)) iscsi_cdb { - uint8_t data[16]; -} iscsi_cdb; /** * @brief iSCSI Extended CDB AHS packet data structure. @@ -633,8 +629,37 @@ typedef struct __attribute__((packed)) iscsi_data_digest { uint32_t crc32c; } iscsi_data_digest; + +/** + * @brief iSCSI CDB packet data structure. + * + * There are 16 bytes in the CDB field to accommodate the commonly used + * CDBs. Whenever the CDB is larger than 16 bytes, an Extended CDB AHS + * MUST be used to contain the CDB spillover. + */ +typedef struct __attribute__((packed)) iscsi_scsi_cdb { + /// SCSI opcode. + uint8_t opcode; + + /// Logical Unit Number (LUN) and EVPD. + uint8_t lun_evpd; + + /// Page code. + uint8_t page_code; + + /// Allocation length in bytes. + uint16_t alloc_len; + + /// Control. + uint8_t control; + + /// Additional data. + uint8_t data[10]; +} iscsi_scsi_cdb; + + /** - * @brief iSCSI DataSegment Command packet structure. + * @brief iSCSI SCSI DataSegment Command packet structure. * * iSCSI targets MUST support and enable Autosense. If Status is CHECK * CONDITION (0x02), then the data segment MUST contain sense data for @@ -644,7 +669,7 @@ typedef struct __attribute__((packed)) iscsi_data_digest { * response-related information (e.g., for a target failure, it may * contain a vendor-specific detailed description of the failure). */ -typedef struct __attribute__((packed)) iscsi_ds_cmd_data { +typedef struct __attribute__((packed)) iscsi_scsi_ds_cmd_data { /// SenseLength: This field indicates the length of Sense Data. uint16_t len; @@ -653,7 +678,384 @@ typedef struct __attribute__((packed)) iscsi_ds_cmd_data { /// Response Data. uint8_t res_data[0]; -} iscsi_ds_cmd_data; +} iscsi_scsi_ds_cmd_data; + + +/// ISCSI SCSI Data peripheral type: Direct access device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_DIRECT 0x00 + +/// ISCSI SCSI Data peripheral type: Sequential access device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_SEQ 0x01 + +/// ISCSI SCSI Data peripheral type: Printer device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_PRINTER 0x02 + +/// ISCSI SCSI Data peripheral type: Processor device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_PROCESSOR 0x03 + +/// ISCSI SCSI Data peripheral type: Write once device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_WORM 0x04 + +/// ISCSI SCSI Data peripheral type: Read only direct access (e.g. CD-ROM) device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_RO_DIRECT 0x05 + +/// ISCSI SCSI Data peripheral type: Scanner device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_SCANNER 0x06 + +/// ISCSI SCSI Data peripheral type: Optical memory device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_OPTICAL 0x07 + +/// ISCSI SCSI Data peripheral type: Medium changer device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_CHANGER 0x08 + +/// ISCSI SCSI Data peripheral type: Communications device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_COMM 0x09 + +/// ISCSI SCSI Data peripheral type: Unknown or no device. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_UNKNOWN 0x1F + +/// ISCSI SCSI Data peripheral type: First bit of the five bits. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FIRST_BIT 0 + +/// ISCSI SCSI Data peripheral type: Second bit of the five bits. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_SECOND_BIT ((ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FIRST_BIT) + 1) + +/// ISCSI SCSI Data peripheral type: Third bit of the five bits. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_THIRD_BIT ((ISCSI_SCSI_DATA_PERIPHERAL_TYPE_SECOND_BIT) + 1) + +/// ISCSI SCSI Data peripheral type: Fourth bit of the five bits. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FOURTH_BIT ((ISCSI_SCSI_DATA_PERIPHERAL_TYPE_THIRD_BIT) + 1) + +/// ISCSI SCSI Data peripheral type: Fourth bit of the five bits. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FIFTH_BIT ((ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FOURTH_BIT) + 1) + +/// ISCSI SCSI Data peripheral type: Bit mask. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_MASK ((1 << (ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FIRST_BIT)) | (1 << (ISCSI_SCSI_DATA_PERIPHERAL_TYPE_SECOND_BIT)) | (1 << (ISCSI_SCSI_DATA_PERIPHERAL_TYPE_THIRD_BIT)) | (1 << (ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FOURTH_BIT)) | (1 << (ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FIFTH_BIT))) + +/// ISCSI SCSI Data peripheral type: Extracts the Peripheral device type bits. +#define ISCSI_SCSI_DATA_GET_PERIPHERAL_TYPE(x) (((x) & ISCSI_SCSI_DATA_PERIPHERAL_TYPE_MASK) >> ISCSI_SCSI_DATA_PERIPHERAL_TYPE_FIRST_BIT) + +/// ISCSI SCSI Data peripheral identifier: The specified peripheral device type is currently connected to this logical unit, or connection state could not be determined. +#define ISCSI_SCSI_DATA_PERIPHERAL_ID_POSSIBLE 0x0 + +/// ISCSI SCSI Data peripheral identifier: The target is capable of supporting the specified peripheral device type on this logical unit, but not connected. +#define ISCSI_SCSI_DATA_PERIPHERAL_ID_SUPPORTED 0x1 + +/// ISCSI SCSI Data peripheral identifier: The target is not capable of supporting a physical device on this logical unit. +#define ISCSI_SCSI_DATA_PERIPHERAL_ID_NEVER 0x3 + +/// ISCSI SCSI Data peripheral identifier: Vendor specific. +#define ISCSI_SCSI_DATA_PERIPHERAL_ID_VENDOR_UNIQ 0x4 + +/// ISCSI SCSI Data peripheral identifier: First bit of the three bits. +#define ISCSI_SCSI_DATA_PERIPHERAL_ID_FIRST_BIT 5 + +/// ISCSI SCSI Data peripheral identifier: Second bit of the fhree bits. +#define ISCSI_SCSI_DATA_PERIPHERAL_ID_SECOND_BIT ((ISCSI_SCSI_DATA_PERIPHERAL_ID_FIRST_BIT) + 1) + +/// ISCSI SCSI Data peripheral identifier: Third bit of the three bits. +#define ISCSI_SCSI_DATA_PERIPHERAL_ID_THIRD_BIT ((ISCSI_SCSI_DATA_PERIPHERAL_ID_SECOND_BIT) + 1) + +/// ISCSI SCSI Data peripheral identifier: Bit mask. +#define ISCSI_SCSI_DATA_PERIPHERAL_ID_MASK ((1 << (ISCSI_SCSI_DATA_PERIPHERAL_ID_FIRST_BIT)) | (1 << (ISCSI_SCSI_DATA_PERIPHERAL_ID_SECOND_BIT)) | (1 << (ISCSI_SCSI_DATA_PERIPHERAL_ID_THIRD_BIT))) + +/// ISCSI SCSI Data peripheral identifier: Extracts the Peripheral device identifier bits. +#define ISCSI_SCSI_DATA_GET_PERIPHERAL_ID(x) (((x) & ISCSI_SCSI_DATA_PERIPHERAL_ID_MASK) >> ISCSI_SCSI_DATA_PERIPHERAL_ID_FIRST_BIT) + + +/// ISCSI SCSI Data peripheral type modifier: Bit mask. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_MOD_MASK 0x7F + +/// ISCSI SCSI Data peripheral type modifier: Removable media. +#define ISCSI_SCSI_DATA_PERIPHERAL_TYPE_MOD_FLAGS_REMOVABLE_MEDIA (1 << 7L) + + +/// ISCSI SCSI Data ANSI version: First bit of the three bits. +#define ISCSI_SCSI_DATA_VERSION_ANSI_FIRST_BIT 0 + +/// ISCSI SCSI Data ANSI version: Second bit of the fhree bits. +#define ISCSI_SCSI_DATA_VERSION_ANSI_SECOND_BIT ((ISCSI_SCSI_DATA_VERSION_ANSI_FIRST_BIT) + 1) + +/// ISCSI SCSI Data ANSI version: Third bit of the three bits. +#define ISCSI_SCSI_DATA_VERSION_ANSI_THIRD_BIT ((ISCSI_SCSI_DATA_VERSION_ANSI_SECOND_BIT) + 1) + +/// ISCSI SCSI Data ANSI version: Bit mask. +#define ISCSI_SCSI_DATA_VERSION_ANSI_MASK ((1 << (ISCSI_SCSI_DATA_VERSION_ANSI_FIRST_BIT)) | (1 << (ISCSI_SCSI_DATA_VERSION_ANSI_SECOND_BIT)) | (1 << (ISCSI_SCSI_DATA_VERSION_ANSI_THIRD_BIT))) + +/// ISCSI SCSI Data ANSI version: Extracts the Peripheral device identifier bits. +#define ISCSI_SCSI_DATA_GET_VERSION_ANSI(x) (((x) & ISCSI_SCSI_DATA_VERSION_ANSI_MASK) >> ISCSI_SCSI_DATA_VERSION_ANSI_FIRST_BIT) + +/// ISCSI SCSI Data ECMA version: First bit of the three bits. +#define ISCSI_SCSI_DATA_VERSION_ECMA_FIRST_BIT 3 + +/// ISCSI SCSI Data ECMA version: Second bit of the fhree bits. +#define ISCSI_SCSI_DATA_VERSION_ECMA_SECOND_BIT ((ISCSI_SCSI_DATA_VERSION_ECMA_FIRST_BIT) + 1) + +/// ISCSI SCSI Data ECMA version: Third bit of the three bits. +#define ISCSI_SCSI_DATA_VERSION_ECMA_THIRD_BIT ((ISCSI_SCSI_DATA_VERSION_ECMA_SECOND_BIT) + 1) + +/// ISCSI SCSI Data ECMA version: Bit mask. +#define ISCSI_SCSI_DATA_VERSION_ECMA_MASK ((1 << (ISCSI_SCSI_DATA_VERSION_ECMA_FIRST_BIT)) | (1 << (ISCSI_SCSI_DATA_VERSION_ECMA_SECOND_BIT)) | (1 << (ISCSI_SCSI_DATA_VERSION_ECMA_THIRD_BIT))) + +/// ISCSI SCSI Data ECMA version: Extracts the Peripheral device identifier bits. +#define ISCSI_SCSI_DATA_GET_VERSION_ECMA(x) (((x) & ISCSI_SCSI_DATA_VERSION_ECMA_MASK) >> ISCSI_SCSI_DATA_VERSION_ECMA_FIRST_BIT) + +/// ISCSI SCSI Data ISO version: First bit of the two bits. +#define ISCSI_SCSI_DATA_VERSION_ISO_FIRST_BIT 6 + +/// ISCSI SCSI Data ISO version: Second bit of the two bits. +#define ISCSI_SCSI_DATA_VERSION_ISO_SECOND_BIT ((ISCSI_SCSI_DATA_VERSION_ISO_FIRST_BIT) + 1) + +/// ISCSI SCSI Data ISO version: Bit mask. +#define ISCSI_SCSI_DATA_VERSION_ISO_MASK ((1 << (ISCSI_SCSI_DATA_VERSION_ISO_FIRST_BIT)) | (1 << (ISCSI_SCSI_DATA_VERSION_ISO_SECOND_BIT))) + +/// ISCSI SCSI Data ISO version: Extracts the Peripheral device identifier bits. +#define ISCSI_SCSI_DATA_GET_VERSION_ISO(x) (((x) & ISCSI_SCSI_DATA_VERSION_ISO_MASK) >> ISCSI_SCSI_DATA_VERSION_ISO_FIRST_BIT) + + +/// ISCSI SCSI Data response data format flags: This structure complies with SCSI-1 specifications. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_LEVEL_0 0x00 + +/// ISCSI SCSI Data response data format flags: This structure complies with CCS pseudo specifications. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_CCS 0x01 + +/// ISCSI SCSI Data response data format flags: This structure complies with SCSI-2/3 specifications. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_SCSI_2 0x02 + +/// ISCSI SCSI Data response data format flags: First bit of the four bits. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_FIRST_BIT 0 + +/// ISCSI SCSI Data response data format flags: Second bit of the four bits. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_SECOND_BIT ((ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_FIRST_BIT) + 1) + +/// ISCSI SCSI Data response data format flags: Third bit of the four bits. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_THIRD_BIT ((ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_SECOND_BIT) + 1) + +/// ISCSI SCSI Data response data format flags: Fourth bit of the four bits. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_FOURTH_BIT ((ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_THIRD_BIT) + 1) + +/// ISCSI SCSI Data response data format flags: Bit mask. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_MASK ((1 << (ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_FIRST_BIT)) | (1 << (ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_SECOND_BIT)) | (1 << (ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_THIRD_BIT)) | (1 << (ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_FOURTH_BIT))) + +/// ISCSI SCSI Data response data format flags: Extracts the Peripheral device type bits. +#define ISCSI_SCSI_DATA_GET_RESPONSE_DATA_FMT_FLAGS(x) (((x) & ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_MASK) >> ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_FIRST_BIT) + +/// ISCSI SCSI Data response data format flags: TERMINATE I/O PROCESS message device support. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_TERMINATE_IO_PROC_MSG (1 << 6L) + +/// ISCSI SCSI Data response data format flags: Asynchronous Event Notification device support. +#define ISCSI_SCSI_DATA_RESPONSE_DATA_FMT_FLAGS_ASYNC_EVENT_NOTIFY (1 << 7L) + + +typedef struct __attribute__((packed)) iscsi_scsi_data_packet { + /// Peripheral device type and qualifier. + uint8_t peripheral_type_id; + + /// Peripheral device type modifier and removable media flag. + int8_t peripheral_type_mod_flags; + + /// ANSI-Approved, ECMA and ISO version. + uint8_t version; + + /// Response data format, AENC and TrmIOP flags. + int8_t response_data_fmt_flags; + + /// Additional length in bytes. + uint8_t add_len; +} iscsi_scsi_data_packet; + + +/// ISCSI SCSI Standard Inquiry Data flags: Device responds with soft reset instead of hard reset to reset condition. +#define ISCSI_SCSI_STD_INQUIRY_DATA_FLAGS_SOFT_RESET (1 << 0L) + +/// ISCSI SCSI Standard Inquiry Data flags: Device supports tagged command queueing. +#define ISCSI_SCSI_STD_INQUIRY_DATA_FLAGS_COMMAND_QUEUE (1 << 1L) + +/// ISCSI SCSI Standard Inquiry Data flags: Reserved for future usage. +#define ISCSI_SCSI_STD_INQUIRY_DATA_FLAGS_RESERVED (1 << 2L) + +/// ISCSI SCSI Standard Inquiry Data flags: Device supports linked commands for this logical unit. +#define ISCSI_SCSI_STD_INQUIRY_DATA_FLAGS_LINKED_CMDS (1 << 3L) + +/// ISCSI SCSI Standard Inquiry Data flags: Device supports synchronous data transfers. +#define ISCSI_SCSI_STD_INQUIRY_DATA_FLAGS_SYNC (1 << 4L) + +/// ISCSI SCSI Standard Inquiry Data flags: Device supports 16-bit wide data transfers. +#define ISCSI_SCSI_STD_INQUIRY_DATA_FLAGS_WIDE_16_BIT (1 << 5L) + +/// ISCSI SCSI Standard Inquiry Data flags: Device supports 32-bit wide data transfers. +#define ISCSI_SCSI_STD_INQUIRY_DATA_FLAGS_WIDE_32_BIT (1 << 6L) + +/// ISCSI SCSI Standard Inquiry Data flags: Device supports relative addressing mode of this logical unit. +#define ISCSI_SCSI_STD_INQUIRY_DATA_FLAGS_REL_ADDR (1 << 7L) + + +typedef struct __attribute__((packed)) iscsi_scsi_std_inquiry_data_packet { + /// iSCSI SCSI data packet. + iscsi_scsi_data_packet scsi_data; + + /// Peripheral device type and qualifier. + uint8_t peripheral_type_id; + + /// Peripheral device type modifier and removable media flag. + int8_t peripheral_type_mod_flags; + + /// ANSI-Approved, ECMA and ISO version. + uint8_t version; + + /// Response data format, AENC and TrmIOP flags. + int8_t response_data_fmt_flags; + + /// Additional length in bytes. + uint8_t add_len; + + /// Reserved for future usage (always MUST be 0 for now). + uint16_t reserved; + + /// Flags. + int8_t flags; + + /// Vendor identification. + uint8_t vendor_id[8]; + + /// Product identification. + uint8_t product_id[16]; + + /// Product revision level. + uint8_t product_rev_level[4]; +} iscsi_scsi_std_inquiry_data_packet; + +/** + * @brief iSCSI SCSI Sense Event data packet. + * + * For a SCSI event, this data accompanies the report in the data + * segment and identifies the condition. + * + * For an iSCSI event, additional vendor-unique data MAY accompany the + * Async event. Initiators MAY ignore the data when not understood, + * while processing the rest of the PDU. + * + * If the DataSegmentLength is not 0, the format of the DataSegment is + * as follows: + */ +typedef struct __attribute__((packed)) iscsi_scsi_sense_event_data_packet { + /** + * @brief SenseLength. + * + * This is the length of Sense Data. When the Sense Data field is empty + * (e.g., the event is not a SCSI event), SenseLength is 0. + */ + uint16_t sense_len; + + /// Sense Data. + uint16_t sense_data[0]; + + /// iSCSI Event Data. + uint16_t event_data[0]; +} iscsi_scsi_sense_event_data_packet; + + +/// iSCSI SCSI sense data response code: Current format. +#define ISCSI_SCSI_SENSE_DATA_RESPONSE_CODE_CURRENT_FMT 0x70 + +/// iSCSI SCSI sense data response code: Current format. +#define ISCSI_SCSI_SENSE_DATA_RESPONSE_CODE_DEFERRED_FMT 0x71 + +/// iSCSI SCSI sense data response code: Valid. +#define ISCSI_SCSI_SENSE_DATA_RESPONSE_CODE_VALID (1 << 7L) + + +/// iSCSI SCSI sense data sense key: First bit of the four bits. +#define ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FIRST_BIT 0 + +/// iSCSI SCSI sense data sense key: Second bit of the four bits. +#define ISCSI_SCSI_SENSE_DATA_SENSE_KEY_SECOND_BIT ((ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FIRST_BIT) + 1) + +/// iSCSI SCSI sense data sense key: Third bit of the four bits. +#define ISCSI_SCSI_SENSE_DATA_SENSE_KEY_THIRD_BIT ((ISCSI_SCSI_SENSE_DATA_SENSE_KEY_SECOND_BIT) + 1) + +/// iSCSI SCSI sense data sense key: Fourth bit of the four bits. +#define ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FOURTH_BIT ((ISCSI_SCSI_SENSE_DATA_SENSE_KEY_THIRD_BIT) + 1) + +/// iSCSI SCSI sense data sense key: Bit mask. +#define ISCSI_SCSI_SENSE_DATA_SENSE_KEY_MASK ((1 << (ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FIRST_BIT)) | (1 << (ISCSI_SCSI_SENSE_DATA_SENSE_KEY_SECOND_BIT)) | (1 << (ISCSI_SCSI_SENSE_DATA_SENSE_KEY_THIRD_BIT)) | (1 << (ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FOURTH_BIT))) + +/// iSCSI SCSI sense data sense key: Extracts the Sense Key (SK) bits. +#define ISCSI_SCSI_SENSE_DATA_GET_SENSE_KEY(x) (((x) & ISCSI_SCSI_SENSE_DATA_SENSE_KEY_MASK) >> ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FIRST_BIT) + +// iSCSI SCSI sense data sense key flags: ILI. +#define ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FLAGS_ILI (1 << 5L) + +// iSCSI SCSI sense data sense key flags: EOM. +#define ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FLAGS_EOM (1 << 6L) + +// iSCSI SCSI sense data sense key flags: FILEMARK. +#define ISCSI_SCSI_SENSE_DATA_SENSE_KEY_FLAGS_FILEMARK (1 << 7L) + + +/** + * @brief iSCSI SCSI basic sense data packet data. + * + * This is the basic SCSI sense data shared by + * all SCSI sense data. + */ +typedef struct __attribute__((packed)) iscsi_scsi_sense_data_packet { + /// Response code. + int8_t response_code; + + /// Reserved for future usage (always MUST be 0). + uint8_t reserved; + + /// Sense key and flags. + int8_t sense_key_flags; + + /// Information. + uint32_t info; + + /// Additional sense length in bytes. + uint8_t add_len; +} iscsi_scsi_sense_data_packet; + +/// iSCSI SCSI maximum sense data length. +#define ISCSI_SCSI_MAX_SENSE_DATA_LEN (sizeof(struct iscsi_scsi_sense_data_packet) + 255UL) + + +// iSCSI SCSI sense data check condition sense key specific bit mask. +#define ISCSI_SCSI_SENSE_DATA_CHECK_COND_SENSE_KEY_SPEC_MASK 0x3F + +// iSCSI SCSI sense data check condition sense key specific flags: SKSV. +#define ISCSI_SCSI_SENSE_DATA_CHECK_COND_SENSE_KEY_SPEC_FLAGS_SKSV (1 << 7L) + + +/** + * @brief iSCSI SCSI sense data check condition packet data. + * + * This is the additional SCSI sense data used by + * the check condition status code. + */ +typedef struct __attribute__((packed)) iscsi_scsi_sense_data_check_cond_packet { + /// Basic SCSI sense data packet. + iscsi_scsi_sense_data_packet sense_data; + + /// Information. + uint32_t cmd_spec_info; + + /// Additional Sense Code (ASC). + uint8_t asc; + + /// Additional Sense Code Qualifier (ASCQ). + uint8_t ascq; + + /// Field replaceable unit code. + uint32_t field_rep_unit_code; + + /// Sense key specific. + uint8_t sense_key_spec_flags; + + /// Sense key specific. + uint16_t sense_key_spec; +} iscsi_scsi_sense_data_check_cond_packet; + /// SCSI command opcode (embedded in iSCSI protocol): TEST UNIT READY. #define ISCSI_SCSI_OPCODE_TESTUNITREADY 0x00 @@ -802,6 +1204,10 @@ typedef struct __attribute__((packed)) iscsi_ds_cmd_data { */ #define ISCSI_SCSI_CMD_FLAGS_TASK_NO_UNSOLICITED_DATA (1 << 7) + +/// SCSI SCSI command flags: Final. +#define ISCSI_SCSI_CMD_FLAGS_FINAL (1 << 7) + /** * @brief iSCSI SCSI command flags: Expected input data. * @@ -925,7 +1331,7 @@ typedef struct __attribute__((packed)) iscsi_scsi_cmd_packet { * CDBs. Whenever the CDB is larger than 16 bytes, an Extended CDB AHS * MUST be used to contain the CDB spillover. */ - iscsi_cdb scsi_cdb; + iscsi_scsi_cdb scsi_cdb; /// Optional AHS packet data. iscsi_ahs_packet ahs; @@ -934,7 +1340,7 @@ typedef struct __attribute__((packed)) iscsi_scsi_cmd_packet { iscsi_header_digest hdr_digest; /// Optional data segment, command data. - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -1260,7 +1666,7 @@ typedef struct __attribute__((packed)) iscsi_scsi_response_packet { iscsi_header_digest hdr_digest; /// Optional data segment, command data. - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -1621,7 +2027,7 @@ typedef struct __attribute__((packed)) iscsi_scsi_data_out_req_packet { iscsi_header_digest hdr_digest; /// Data segment. - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -1833,7 +2239,7 @@ typedef struct __attribute__((packed)) iscsi_scsi_data_in_response_packet { iscsi_header_digest hdr_digest; /// Data segment. - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -2148,7 +2554,7 @@ typedef struct __attribute__((packed)) iscsi_async_msg_packet { iscsi_header_digest hdr_digest; /// Data segment. - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -2156,36 +2562,6 @@ typedef struct __attribute__((packed)) iscsi_async_msg_packet { /** - * @brief iSCSI Sense Event data packet. - * - * For a SCSI event, this data accompanies the report in the data - * segment and identifies the condition. - * - * For an iSCSI event, additional vendor-unique data MAY accompany the - * Async event. Initiators MAY ignore the data when not understood, - * while processing the rest of the PDU. - * - * If the DataSegmentLength is not 0, the format of the DataSegment is - * as follows: - */ -typedef struct __attribute__((packed)) iscsi_sense_event_data_packet { - /** - * @brief SenseLength. - * - * This is the length of Sense Data. When the Sense Data field is empty - * (e.g., the event is not a SCSI event), SenseLength is 0. - */ - uint16_t sense_len; - - /// Sense Data. - uint16_t sense_data[0]; - - /// iSCSI Event Data. - uint16_t event_data[0]; -} iscsi_sense_event_data_packet; - - -/** * @brief Text Request flags: Continue. * * (C) When set to 1, this bit indicates that the text (set of key=value @@ -2316,7 +2692,7 @@ typedef struct __attribute__((packed)) iscsi_text_req_packet { * Text operations are usually meant for parameter setting/negotiations * but can also be used to perform some long-lasting operations. */ - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -2438,7 +2814,7 @@ typedef struct __attribute__((packed)) iscsi_text_response_packet { * key=value pairs of its own as part of a sequence and not only in * response to the initiator. */ - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -4461,7 +4837,7 @@ typedef struct __attribute__((packed)) iscsi_login_req_packet { * to enable the target to determine if the initiator may use * the target's resources and the initial text parameters for the security exchange */ - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; } iscsi_login_req_packet; @@ -4803,7 +5179,7 @@ typedef struct __attribute__((packed)) iscsi_login_response_packet { * All the rules specified for Text Responses also hold for Login * Responses. */ - iscsi_ds_cmd_data ds_cmd_data; + iscsi_scsi_ds_cmd_data ds_cmd_data; } iscsi_login_response_packet; @@ -5529,7 +5905,7 @@ typedef struct __attribute__((packed)) iscsi_nop_out_packet { * ping data is indicated by the DataSegmentLength. 0 is a valid value * for the DataSegmentLength and indicates the absence of ping data. */ - iscsi_ds_cmd_data ds_ping_data; + iscsi_scsi_ds_cmd_data ds_ping_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -5618,7 +5994,7 @@ typedef struct __attribute__((packed)) iscsi_nop_in_packet { iscsi_header_digest hdr_digest; /// DataSegment - Return Ping Data. - iscsi_ds_cmd_data ds_ping_data; + iscsi_scsi_ds_cmd_data ds_ping_data; /// Optional data digest. iscsi_data_digest data_digest; @@ -5968,6 +6344,186 @@ iscsi_portal *iscsi_portal_create(const uint8_t *host, const uint8_t *port); // void iscsi_portal_destroy(iscsi_portal *portal); +/// iSCSI SCSI task flags: Read. +#define ISCSI_SCSI_TASK_FLAGS_XFER_READ (1 << 0L) + +/// iSCSI SCSI task flags: Write. +#define ISCSI_SCSI_TASK_FLAGS_XFER_WRITE (1 << 1L) + + +/// iSCSI SCSI status code: Good. +#define ISCSI_SCSI_STATUS_GOOD 0x00 + +/// iSCSI SCSI status code: Check condition. +#define ISCSI_SCSI_STATUS_CHECK_COND 0x02 + +/// iSCSI SCSI status code: Condition met. +#define ISCSI_SCSI_STATUS_COND_MET 0x04 + +/// iSCSI SCSI status code: Busy. +#define ISCSI_SCSI_STATUS_BUSY 0x08 + +/// iSCSI SCSI status code: Intermediate. +#define ISCSI_SCSI_STATUS_INTERMEDIATE 0x10 + +/// iSCSI SCSI status code: Intermediate condition met. +#define ISCSI_SCSI_STATUS_INTERMEDIATE_COND_MET 0x14 + +/// iSCSI SCSI status code: Reservation conflict. +#define ISCSI_SCSI_STATUS_RESERVATION_CONFLICT 0x18 + +/// iSCSI SCSI status code: Obselete. +#define ISCSI_SCSI_STATUS_OBSELETE 0x22 + +/// iSCSI SCSI status code: Task set full. +#define ISCSI_SCSI_STATUS_TASK_SET_FULL 0x28 + +/// iSCSI SCSI status code: ACA active. +#define ISCSI_SCSI_STATUS_ACA_ACTIVE 0x30 + +/// iSCSI SCSI status code: Task aborted. +#define ISCSI_SCSI_STATUS_TASK_ABORTED 0x40 + + +/// iSCSI SCSI sense key: No sense. +#define ISCSI_SCSI_SENSE_KEY_NO_SENSE 0x00 + +/// iSCSI SCSI sense key: Recovered error. +#define ISCSI_SCSI_SENSE_KEY_RECOVERED_ERR 0x01 + +/// iSCSI SCSI sense key: Not ready. +#define ISCSI_SCSI_SENSE_KEY_NOT_READY 0x02 + +/// iSCSI SCSI sense key: Medium error. +#define ISCSI_SCSI_SENSE_KEY_MEDIUM_ERR 0x03 + +/// iSCSI SCSI sense key: Hardware error. +#define ISCSI_SCSI_SENSE_KEY_HARDWARE_ERR 0x04 + +/// iSCSI SCSI sense key: Illegal request. +#define ISCSI_SCSI_SENSE_KEY_ILLEGAL_REQ 0x05 + +/// iSCSI SCSI sense key: Unit attention. +#define ISCSI_SCSI_SENSE_KEY_UNIT_ATTENTION 0x06 + +/// iSCSI SCSI sense key: Data protect. +#define ISCSI_SCSI_SENSE_KEY_DATA_PROTECT 0x07 + +/// iSCSI SCSI sense key: Blank check. +#define ISCSI_SCSI_SENSE_KEY_BLANK_CHECK 0x08 + +/// iSCSI SCSI sense key: Vendor specific. +#define ISCSI_SCSI_SENSE_KEY_VENDOR_SPECIFIC 0x09 + +/// iSCSI SCSI sense key: Copy aborted. +#define ISCSI_SCSI_SENSE_KEY_COPY_ABORTED 0x0A + +/// iSCSI SCSI sense key: Aborted command. +#define ISCSI_SCSI_SENSE_KEY_ABORTED_COMMAND 0x0B + +/// iSCSI SCSI sense key: Volume overflow. +#define ISCSI_SCSI_SENSE_KEY_VOLUME_OVERFLOW 0x0D + +/// iSCSI SCSI sense key: Miscompare. +#define ISCSI_SCSI_SENSE_KEY_MISCOMPARE 0x0E + + +/// iSCSI SCSI Additional Sense Code (ASC): No additional sense. +#define ISCSI_SCSI_ASC_NO_ADDITIONAL_SENSE 0x00 + +/// iSCSI SCSI Additional Sense Code (ASC): Peripheral device write fault. +#define ISCSI_SCSI_ASC_PERIPHERAL_DEVICE_WRITE_FAULT 0x03 + +/// iSCSI SCSI Additional Sense Code (ASC): Logical unit not ready. +#define ISCSI_SCSI_ASC_LOGICAL_UNIT_NOT_READY 0x04 + +/// iSCSI SCSI Additional Sense Code (ASC): Warning. +#define ISCSI_SCSI_ASC_WARNING 0x0B + +/// iSCSI SCSI Additional Sense Code (ASC): Block guard check failed. +#define ISCSI_SCSI_ASC_LOGICAL_BLOCK_GUARD_CHECK_FAIL 0x10 + +/// iSCSI SCSI Additional Sense Code (ASC): Block application tag checdk failed. +#define ISCSI_SCSI_ASC_LOGICAL_BLOCK_APP_TAG_CHECK_FAIL 0x10 + +/// iSCSI SCSI Additional Sense Code (ASC): Block reference tag check failed. +#define ISCSI_SCSI_ASC_LOGICAL_BLOCK_REF_TAG_CHECK_FAIL 0x10 + +/// iSCSI SCSI Additional Sense Code (ASC): Unrecovered read error. +#define ISCSI_SCSI_ASC_UNRECOVERED_READ_ERR 0x11 + +/// iSCSI SCSI Additional Sense Code (ASC): Miscompare during verify operation. +#define ISCSI_SCSI_ASC_MISCOMPARE_DURING_VERIFY_OPERATION 0x1D + +/// iSCSI SCSI Additional Sense Code (ASC): Invalid command operation code. +#define ISCSI_SCSI_ASC_INVALID_COMMAND_OPERATION_CODE 0x20 + +/// iSCSI SCSI Additional Sense Code (ASC): Access denied. +#define ISCSI_SCSI_ASC_ACCESS_DENIED 0x20 + +/// iSCSI SCSI Additional Sense Code (ASC): Logical block address out of range. +#define ISCSI_SCSI_ASC_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE 0x21 + +/// iSCSI SCSI Additional Sense Code (ASC): Invalid field in CDB. +#define ISCSI_SCSI_ASC_INVALID_FIELD_IN_CDB 0x24 + +/// iSCSI SCSI Additional Sense Code (ASC): Logical unit not supported. +#define ISCSI_SCSI_ASC_LU_NOT_SUPPORTED 0x25 + +/// iSCSI SCSI Additional Sense Code (ASC): Write protected. +#define ISCSI_SCSI_ASC_WRITE_PROTECTED 0x27 + +/// iSCSI SCSI Additional Sense Code (ASC): Data has changed. +#define ISCSI_SCSI_ASC_CAPACITY_DATA_HAS_CHANGED 0x2A + +/// iSCSI SCSI Additional Sense Code (ASC): Format command failed. +#define ISCSI_SCSI_ASC_FORMAT_COMMAND_FAIL 0x31 + +/// iSCSI SCSI Additional Sense Code (ASC): Saving parameters not supported. +#define ISCSI_SCSI_ASC_SAVING_PARAMETERS_NOT_SUPPORTED 0x39 + +/// iSCSI SCSI Additional Sense Code (ASC): Internal target failure. +#define ISCSI_SCSI_ASC_INTERNAL_TARGET_FAIL 0x44 + + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Cause not reportable. +#define ISCSI_SCSI_ASCQ_CAUSE_NOT_REPORTABLE 0x00 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Becoming ready. +#define ISCSI_SCSI_ASCQ_BECOMING_READY 0x01 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Format command failed. +#define ISCSI_SCSI_ASCQ_FORMAT_COMMAND_FAIL 0x01 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Block guard check failed. +#define ISCSI_SCSI_ASCQ_LOGICAL_BLOCK_GUARD_CHECK_FAIL 0x01 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Block application tag check failed. +#define ISCSI_SCSI_ASCQ_LOGICAL_BLOCK_APP_TAG_CHECK_FAIL 0x02 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): No access rights. +#define ISCSI_SCSI_ASCQ_NO_ACCESS_RIGHTS 0x02 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Block reference tag check failed. +#define ISCSI_SCSI_ASCQ_LOGICAL_BLOCK_REF_TAG_CHECK_FAIL 0x03 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Power loss expected. +#define ISCSI_SCSI_ASCQ_POWER_LOSS_EXPECTED 0x08 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Invalid logical unit identifier. +#define ISCSI_SCSI_ASCQ_INVALID_LU_IDENTIFIER 0x09 + +/// iSCSI SCSI Additional Sense Code Qualifier (ASCQ): Capacity data has changed. +#define ISCSI_SCSI_ASCQ_CAPACITY_DATA_HAS_CHANGED 0x09 + + +/// Callback function when SCSI transfer is completed. +typedef void (*iscsi_scsi_task_xfer_complete_callback)(struct iscsi_scsi_task *scsi_task); + +/// Callback function for SCSI task destruction. +typedef void (*iscsi_scsi_task_destroy_callback)(struct iscsi_scsi_task *scsi_task); + + /** * @brief iSCSI SCSI Task. * @@ -5975,24 +6531,69 @@ void iscsi_portal_destroy(iscsi_portal *portal); * layer task management. */ typedef struct iscsi_scsi_task { + /// SCSI LUN associated with this task. + struct iscsi_lun *lun; + /// Target iSCSI port. struct iscsi_port *target_port; /// Initiator iSCSI port. struct iscsi_port *init_port; + /// SCSI Command Descriptor Block (CDB). + iscsi_scsi_cdb *cdb; + + /// SCSI sense data. + iscsi_scsi_sense_data_packet *sense_data; + + /// Transfer complete callback function. + iscsi_scsi_task_xfer_complete_callback xfer_complete_callback; + + /// Task destruction callback function. + iscsi_scsi_task_destroy_callback destroy_callback; + + /// Output buffer. + uint8_t *buf; + + /// Position of buffer in bytes. + uint pos; + + /// Length of buffer in bytes. + uint len; + + /// Flags. + int flags; + /// Reference counter. uint32_t ref; /// Transfer length in bytes. uint32_t xfer_len; + + /// Sense data length. + uint8_t sense_data_len; + + /// iSCSI SCSI status code. + uint8_t status; + + /// Task management function. + uint8_t task_mgmt_func; + + /// Task management response code. + uint8_t task_mgmt_response; } iscsi_scsi_task; /// ISCSI port flags: In use. #define ISCSI_PORT_FLAGS_IN_USE (1 << 0L) -void iscsi_scsi_task_put(iscsi_scsi_task *scsi_task); // Enqueues a SCSI task for execution +void iscsi_scsi_task_create(iscsi_scsi_task *scsi_task, iscsi_scsi_task_xfer_complete_callback xfer_complete_callback, iscsi_scsi_task_destroy_callback destroy_callback); // Allocates and initializes a SCSI task +void iscsi_scsi_task_destroy(iscsi_scsi_task *scsi_task); // Deallocates all resources acquired iscsi_scsi_task_create + +void iscsi_scsi_task_xfer_complete(iscsi_scsi_task *scsi_task); // Callback function when an iSCSI SCSI task completed the data transfer + +void iscsi_scsi_task_sense_data_build(iscsi_scsi_task *scsi_task, const uint8_t sense_key, const uint8_t asc, const uint8_t ascq); // Allocates, if necessary and initializes SCSI sense data +void iscsi_scsi_task_lun_process_none(iscsi_scsi_task *scsi_task); // Processes a iSCSI SCSI task with no LUN identifier /** @@ -6055,6 +6656,23 @@ typedef struct iscsi_lun { /** + * @brief iSCSI Basic Header Segment (BHS) search in active and queued Ready To Transfer (R2T) tasks. + * + * This structure is used by iterating through + * all active and enqueued Ready To Transfer + * (R2T) tasks for finding an iSCSI PDU + * Basic Header Segment (BHS). + */ +typedef struct iscsi_r2t_find_bhs { + /// Found iSCSI PDU is stored here, should be initialized to NULL. + struct iscsi_pdu *pdu; + + /// iSCSI Basic Header Segment (BHS) to be searched for. + iscsi_bhs_packet *bhs_pkt; +} iscsi_r2t_find_bhs; + + +/** * @brief iSCSI PDU search and removal by Ready To Transfer Sequence Number (R2TSN). * * This structure is used by iterating through @@ -6280,7 +6898,7 @@ typedef struct iscsi_session { iscsi_hashmap *connections; /// Initiator port. - iscsi_port *initiator_port; + iscsi_port *init_port; /// Login key / value pairs negotiated with this session. iscsi_hashmap *key_value_pairs; @@ -6471,12 +7089,21 @@ typedef struct iscsi_connection { /// Hash map containing SNACK PDU's associated with this connection. iscsi_hashmap *pdu_snack; - /// Active Ready To Transfer Tasks. + /// Active Ready To Transfer (R2T) tasks. iscsi_hashmap *r2t_tasks_active; + /// Queued Ready To Transfer (R2T) tasks. + iscsi_hashmap *r2t_tasks_queue; + /// iSCSI SendTargets total number of bytes completed. uint target_send_total_size; + /// iSCSI SCSI data read count. + uint scsi_data_read_cnt; + + /// iSCSI tasks pending count. + uint task_cnt; + /// iSCSI connection contains a header digest (CRC32), always MUST be 0 or 4 for now. int header_digest; @@ -6564,7 +7191,7 @@ typedef struct iscsi_pdu { iscsi_header_digest *header_digest; /// iSCSI DataSegment (DS) packet data for fast access and is straight after BHS, AHS and header digest packet in memory. - iscsi_ds_cmd_data *ds_cmd_data; + iscsi_scsi_ds_cmd_data *ds_cmd_data; /// Data digest (CRC32C) packet data for fast access and is straight after BHS, AHS, header digest and DataSegment packet in memory. iscsi_data_digest *data_digest; @@ -6572,6 +7199,9 @@ typedef struct iscsi_pdu { /// iSCSI task handling this PDU. struct iscsi_task *task; + /// Associated iSCSI connection. + iscsi_connection *conn; + /// Transfer complete callback function. iscsi_connection_xfer_complete_callback xfer_complete_callback; @@ -6611,8 +7241,8 @@ typedef struct iscsi_pdu { /// Allocated DataSegment buffer length. uint len; - /// Associated iSCSI connection. - iscsi_connection *conn; + /// Tasks referenced by this PDU counter. + uint task_ref_cnt; /// CmdSN. uint32_t cmd_sn; @@ -6636,6 +7266,9 @@ typedef struct iscsi_task { /// Underlying SCSI task structure. iscsi_scsi_task scsi_task; + /// Parent iSCSI task. + struct iscsi_task *parent; + /// Associated iSCSI connection. iscsi_connection *conn; @@ -6645,6 +7278,9 @@ typedef struct iscsi_task { /// Buffer to send to initiator. uint8_t *buf; + /// Buffer position in bytes. + uint pos; + /// Buffer length in bytes. uint len; @@ -6696,11 +7332,14 @@ typedef struct iscsi_task_find_tag { } iscsi_task_find_tag; -void iscsi_task_put(iscsi_task *task); // Enqueues an iSCSI task into it's underlying SCSI management structure +iscsi_task *iscsi_task_create(iscsi_connection *conn, iscsi_task *parent, iscsi_scsi_task_xfer_complete_callback callback); // Allocates and initializes an iSCSI task structure +void iscsi_task_destroy(iscsi_task *task); // Deallocates resources acquired by iscsi_task_create int iscsi_task_find_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data); // Finds an iSCSI task by Target Transfer Tag (TTT) int iscsi_device_find_lun_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data); // Finds an iSCSI LUN by LUN identifier +void iscsi_task_response(iscsi_connection *conn, iscsi_task *task); // + iscsi_lun *iscsi_lun_create(const uint id); // Allocates and initializes an iSCSI LUN structure for linkage with a DNBD3 image void iscsi_lun_destroy(iscsi_lun *lun); // Deallocates all resources acquired by iscsi_lun_create @@ -6748,6 +7387,10 @@ void iscsi_connection_pdu_free(iscsi_connection *conn, iscsi_pdu *pdu); // Frees void iscsi_connection_pdu_ack_remove(iscsi_connection *conn, const uint32_t exp_stat_sn); // Removes an acknowledged PDU from SNACK PDU hash map by ExpStatSN +int iscsi_r2t_find_pdu_bhs_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data); // Finds an iSCSI PDU by Basic Header Segment (BHS) in either the Ready To Transfer (R2T) active and queued task hash map +iscsi_pdu *iscsi_r2t_find_pdu_bhs(iscsi_connection *conn, iscsi_pdu *pdu); // Searches an iSCSI PDU by Basic Header Segment (BHS) in the Ready To Transfer (R2T) active and queued task hash map +int iscsi_r2t_remove_pdu_from_snack_list_callback(uint8_t *key, const size_t key_size, uint8_t *value, uint8_t *user_data); // Finds and removes an iSCSI PDU by Ready To Transfer Sequence Number (R2TSN) + int iscsi_connection_read_data(iscsi_connection *conn, int len, void *buf); int iscsi_connection_read_iov_data(iscsi_connection *conn, struct iovec *iov, int iov_count); void iscsi_connection_pdu_write(iscsi_connection *conn, iscsi_pdu *pdu, iscsi_connection_xfer_complete_callback callback, uint8_t *user_data); |