457 lines
14 KiB
C
457 lines
14 KiB
C
/*-
|
|
* Copyright (c) 2012 The FreeBSD Foundation
|
|
* All rights reserved.
|
|
*
|
|
* This software was developed by Edward Tomasz Napierala under sponsorship
|
|
* from the FreeBSD Foundation.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#ifndef ISCSI_PROTO_H
|
|
#define ISCSI_PROTO_H
|
|
|
|
#ifndef CTASSERT
|
|
#define CTASSERT(x) _CTASSERT(x, __LINE__)
|
|
#define _CTASSERT(x, y) __CTASSERT(x, y)
|
|
#define __CTASSERT(x, y) typedef char __assert_ ## y [(x) ? 1 : -1]
|
|
#endif
|
|
|
|
#define ISCSI_SNGT(x, y) ((int32_t)(x) - (int32_t)(y) > 0)
|
|
#define ISCSI_SNLT(x, y) ((int32_t)(x) - (int32_t)(y) < 0)
|
|
|
|
#define ISCSI_BHS_SIZE 48
|
|
#define ISCSI_HEADER_DIGEST_SIZE 4
|
|
#define ISCSI_DATA_DIGEST_SIZE 4
|
|
|
|
#define ISCSI_BHS_OPCODE_IMMEDIATE 0x40
|
|
|
|
#define ISCSI_BHS_OPCODE_NOP_OUT 0x00
|
|
#define ISCSI_BHS_OPCODE_SCSI_COMMAND 0x01
|
|
#define ISCSI_BHS_OPCODE_TASK_REQUEST 0x02
|
|
#define ISCSI_BHS_OPCODE_LOGIN_REQUEST 0x03
|
|
#define ISCSI_BHS_OPCODE_TEXT_REQUEST 0x04
|
|
#define ISCSI_BHS_OPCODE_SCSI_DATA_OUT 0x05
|
|
#define ISCSI_BHS_OPCODE_LOGOUT_REQUEST 0x06
|
|
|
|
#define ISCSI_BHS_OPCODE_NOP_IN 0x20
|
|
#define ISCSI_BHS_OPCODE_SCSI_RESPONSE 0x21
|
|
#define ISCSI_BHS_OPCODE_TASK_RESPONSE 0x22
|
|
#define ISCSI_BHS_OPCODE_LOGIN_RESPONSE 0x23
|
|
#define ISCSI_BHS_OPCODE_TEXT_RESPONSE 0x24
|
|
#define ISCSI_BHS_OPCODE_SCSI_DATA_IN 0x25
|
|
#define ISCSI_BHS_OPCODE_LOGOUT_RESPONSE 0x26
|
|
#define ISCSI_BHS_OPCODE_R2T 0x31
|
|
#define ISCSI_BHS_OPCODE_ASYNC_MESSAGE 0x32
|
|
#define ISCSI_BHS_OPCODE_REJECT 0x3f
|
|
|
|
struct iscsi_bhs {
|
|
uint8_t bhs_opcode;
|
|
uint8_t bhs_opcode_specific1[3];
|
|
uint8_t bhs_total_ahs_len;
|
|
uint8_t bhs_data_segment_len[3];
|
|
uint64_t bhs_lun;
|
|
uint8_t bhs_inititator_task_tag[4];
|
|
uint8_t bhs_opcode_specific4[28];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSSC_FLAGS_F 0x80
|
|
#define BHSSC_FLAGS_R 0x40
|
|
#define BHSSC_FLAGS_W 0x20
|
|
#define BHSSC_FLAGS_ATTR 0x07
|
|
|
|
#define BHSSC_FLAGS_ATTR_UNTAGGED 0
|
|
#define BHSSC_FLAGS_ATTR_SIMPLE 1
|
|
#define BHSSC_FLAGS_ATTR_ORDERED 2
|
|
#define BHSSC_FLAGS_ATTR_HOQ 3
|
|
#define BHSSC_FLAGS_ATTR_ACA 4
|
|
|
|
struct iscsi_bhs_scsi_command {
|
|
uint8_t bhssc_opcode;
|
|
uint8_t bhssc_flags;
|
|
uint8_t bhssc_reserved[2];
|
|
uint8_t bhssc_total_ahs_len;
|
|
uint8_t bhssc_data_segment_len[3];
|
|
uint64_t bhssc_lun;
|
|
uint32_t bhssc_initiator_task_tag;
|
|
uint32_t bhssc_expected_data_transfer_length;
|
|
uint32_t bhssc_cmdsn;
|
|
uint32_t bhssc_expstatsn;
|
|
uint8_t bhssc_cdb[16];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_scsi_command) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSSR_FLAGS_RESIDUAL_UNDERFLOW 0x02
|
|
#define BHSSR_FLAGS_RESIDUAL_OVERFLOW 0x04
|
|
|
|
#define BHSSR_RESPONSE_COMMAND_COMPLETED 0x00
|
|
|
|
struct iscsi_bhs_scsi_response {
|
|
uint8_t bhssr_opcode;
|
|
uint8_t bhssr_flags;
|
|
uint8_t bhssr_response;
|
|
uint8_t bhssr_status;
|
|
uint8_t bhssr_total_ahs_len;
|
|
uint8_t bhssr_data_segment_len[3];
|
|
uint16_t bhssr_status_qualifier;
|
|
uint16_t bhssr_reserved;
|
|
uint32_t bhssr_reserved2;
|
|
uint32_t bhssr_initiator_task_tag;
|
|
uint32_t bhssr_snack_tag;
|
|
uint32_t bhssr_statsn;
|
|
uint32_t bhssr_expcmdsn;
|
|
uint32_t bhssr_maxcmdsn;
|
|
uint32_t bhssr_expdatasn;
|
|
uint32_t bhssr_bidirectional_read_residual_count;
|
|
uint32_t bhssr_residual_count;
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_scsi_response) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSTMR_FUNCTION_ABORT_TASK 1
|
|
#define BHSTMR_FUNCTION_ABORT_TASK_SET 2
|
|
#define BHSTMR_FUNCTION_CLEAR_ACA 3
|
|
#define BHSTMR_FUNCTION_CLEAR_TASK_SET 4
|
|
#define BHSTMR_FUNCTION_LOGICAL_UNIT_RESET 5
|
|
#define BHSTMR_FUNCTION_TARGET_WARM_RESET 6
|
|
#define BHSTMR_FUNCTION_TARGET_COLD_RESET 7
|
|
#define BHSTMR_FUNCTION_TASK_REASSIGN 8
|
|
#define BHSTMR_FUNCTION_QUERY_TASK 9
|
|
#define BHSTMR_FUNCTION_QUERY_TASK_SET 10
|
|
#define BHSTMR_FUNCTION_I_T_NEXUS_RESET 11
|
|
#define BHSTMR_FUNCTION_QUERY_ASYNC_EVENT 12
|
|
|
|
struct iscsi_bhs_task_management_request {
|
|
uint8_t bhstmr_opcode;
|
|
uint8_t bhstmr_function;
|
|
uint8_t bhstmr_reserved[2];
|
|
uint8_t bhstmr_total_ahs_len;
|
|
uint8_t bhstmr_data_segment_len[3];
|
|
uint64_t bhstmr_lun;
|
|
uint32_t bhstmr_initiator_task_tag;
|
|
uint32_t bhstmr_referenced_task_tag;
|
|
uint32_t bhstmr_cmdsn;
|
|
uint32_t bhstmr_expstatsn;
|
|
uint32_t bhstmr_refcmdsn;
|
|
uint32_t bhstmr_expdatasn;
|
|
uint64_t bhstmr_reserved2;
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_task_management_request) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSTMR_RESPONSE_FUNCTION_COMPLETE 0
|
|
#define BHSTMR_RESPONSE_TASK_DOES_NOT_EXIST 1
|
|
#define BHSTMR_RESPONSE_LUN_DOES_NOT_EXIST 2
|
|
#define BHSTMR_RESPONSE_TASK_STILL_ALLEGIANT 3
|
|
#define BHSTMR_RESPONSE_TASK_ALL_REASS_NOT_SUPP 4
|
|
#define BHSTMR_RESPONSE_FUNCTION_NOT_SUPPORTED 5
|
|
#define BHSTMR_RESPONSE_FUNCTION_AUTH_FAIL 6
|
|
#define BHSTMR_RESPONSE_FUNCTION_SUCCEEDED 7
|
|
#define BHSTMR_RESPONSE_FUNCTION_REJECTED 255
|
|
|
|
struct iscsi_bhs_task_management_response {
|
|
uint8_t bhstmr_opcode;
|
|
uint8_t bhstmr_flags;
|
|
uint8_t bhstmr_response;
|
|
uint8_t bhstmr_reserved;
|
|
uint8_t bhstmr_total_ahs_len;
|
|
uint8_t bhstmr_data_segment_len[3];
|
|
uint8_t bhstmr_additional_reponse_information[3];
|
|
uint8_t bhstmr_reserved2[5];
|
|
uint32_t bhstmr_initiator_task_tag;
|
|
uint32_t bhstmr_reserved3;
|
|
uint32_t bhstmr_statsn;
|
|
uint32_t bhstmr_expcmdsn;
|
|
uint32_t bhstmr_maxcmdsn;
|
|
uint8_t bhstmr_reserved4[12];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_task_management_response) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSLR_FLAGS_TRANSIT 0x80
|
|
#define BHSLR_FLAGS_CONTINUE 0x40
|
|
|
|
#define BHSLR_STAGE_SECURITY_NEGOTIATION 0
|
|
#define BHSLR_STAGE_OPERATIONAL_NEGOTIATION 1
|
|
#define BHSLR_STAGE_FULL_FEATURE_PHASE 3 /* Yes, 3. */
|
|
|
|
struct iscsi_bhs_login_request {
|
|
uint8_t bhslr_opcode;
|
|
uint8_t bhslr_flags;
|
|
uint8_t bhslr_version_max;
|
|
uint8_t bhslr_version_min;
|
|
uint8_t bhslr_total_ahs_len;
|
|
uint8_t bhslr_data_segment_len[3];
|
|
uint8_t bhslr_isid[6];
|
|
uint16_t bhslr_tsih;
|
|
uint32_t bhslr_initiator_task_tag;
|
|
uint16_t bhslr_cid;
|
|
uint16_t bhslr_reserved;
|
|
uint32_t bhslr_cmdsn;
|
|
uint32_t bhslr_expstatsn;
|
|
uint8_t bhslr_reserved2[16];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_login_request) == ISCSI_BHS_SIZE);
|
|
|
|
struct iscsi_bhs_login_response {
|
|
uint8_t bhslr_opcode;
|
|
uint8_t bhslr_flags;
|
|
uint8_t bhslr_version_max;
|
|
uint8_t bhslr_version_active;
|
|
uint8_t bhslr_total_ahs_len;
|
|
uint8_t bhslr_data_segment_len[3];
|
|
uint8_t bhslr_isid[6];
|
|
uint16_t bhslr_tsih;
|
|
uint32_t bhslr_initiator_task_tag;
|
|
uint32_t bhslr_reserved;
|
|
uint32_t bhslr_statsn;
|
|
uint32_t bhslr_expcmdsn;
|
|
uint32_t bhslr_maxcmdsn;
|
|
uint8_t bhslr_status_class;
|
|
uint8_t bhslr_status_detail;
|
|
uint16_t bhslr_reserved2;
|
|
uint8_t bhslr_reserved3[8];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_login_response) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSTR_FLAGS_FINAL 0x80
|
|
#define BHSTR_FLAGS_CONTINUE 0x40
|
|
|
|
struct iscsi_bhs_text_request {
|
|
uint8_t bhstr_opcode;
|
|
uint8_t bhstr_flags;
|
|
uint16_t bhstr_reserved;
|
|
uint8_t bhstr_total_ahs_len;
|
|
uint8_t bhstr_data_segment_len[3];
|
|
uint64_t bhstr_lun;
|
|
uint32_t bhstr_initiator_task_tag;
|
|
uint32_t bhstr_target_transfer_tag;
|
|
uint32_t bhstr_cmdsn;
|
|
uint32_t bhstr_expstatsn;
|
|
uint8_t bhstr_reserved2[16];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_text_request) == ISCSI_BHS_SIZE);
|
|
|
|
struct iscsi_bhs_text_response {
|
|
uint8_t bhstr_opcode;
|
|
uint8_t bhstr_flags;
|
|
uint16_t bhstr_reserved;
|
|
uint8_t bhstr_total_ahs_len;
|
|
uint8_t bhstr_data_segment_len[3];
|
|
uint64_t bhstr_lun;
|
|
uint32_t bhstr_initiator_task_tag;
|
|
uint32_t bhstr_target_transfer_tag;
|
|
uint32_t bhstr_statsn;
|
|
uint32_t bhstr_expcmdsn;
|
|
uint32_t bhstr_maxcmdsn;
|
|
uint8_t bhstr_reserved2[12];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_text_response) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSDO_FLAGS_F 0x80
|
|
|
|
struct iscsi_bhs_data_out {
|
|
uint8_t bhsdo_opcode;
|
|
uint8_t bhsdo_flags;
|
|
uint8_t bhsdo_reserved[2];
|
|
uint8_t bhsdo_total_ahs_len;
|
|
uint8_t bhsdo_data_segment_len[3];
|
|
uint64_t bhsdo_lun;
|
|
uint32_t bhsdo_initiator_task_tag;
|
|
uint32_t bhsdo_target_transfer_tag;
|
|
uint32_t bhsdo_reserved2;
|
|
uint32_t bhsdo_expstatsn;
|
|
uint32_t bhsdo_reserved3;
|
|
uint32_t bhsdo_datasn;
|
|
uint32_t bhsdo_buffer_offset;
|
|
uint32_t bhsdo_reserved4;
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_data_out) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSDI_FLAGS_F 0x80
|
|
#define BHSDI_FLAGS_A 0x40
|
|
#define BHSDI_FLAGS_O 0x04
|
|
#define BHSDI_FLAGS_U 0x02
|
|
#define BHSDI_FLAGS_S 0x01
|
|
|
|
struct iscsi_bhs_data_in {
|
|
uint8_t bhsdi_opcode;
|
|
uint8_t bhsdi_flags;
|
|
uint8_t bhsdi_reserved;
|
|
uint8_t bhsdi_status;
|
|
uint8_t bhsdi_total_ahs_len;
|
|
uint8_t bhsdi_data_segment_len[3];
|
|
uint64_t bhsdi_lun;
|
|
uint32_t bhsdi_initiator_task_tag;
|
|
uint32_t bhsdi_target_transfer_tag;
|
|
uint32_t bhsdi_statsn;
|
|
uint32_t bhsdi_expcmdsn;
|
|
uint32_t bhsdi_maxcmdsn;
|
|
uint32_t bhsdi_datasn;
|
|
uint32_t bhsdi_buffer_offset;
|
|
uint32_t bhsdi_residual_count;
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_data_in) == ISCSI_BHS_SIZE);
|
|
|
|
struct iscsi_bhs_r2t {
|
|
uint8_t bhsr2t_opcode;
|
|
uint8_t bhsr2t_flags;
|
|
uint16_t bhsr2t_reserved;
|
|
uint8_t bhsr2t_total_ahs_len;
|
|
uint8_t bhsr2t_data_segment_len[3];
|
|
uint64_t bhsr2t_lun;
|
|
uint32_t bhsr2t_initiator_task_tag;
|
|
uint32_t bhsr2t_target_transfer_tag;
|
|
uint32_t bhsr2t_statsn;
|
|
uint32_t bhsr2t_expcmdsn;
|
|
uint32_t bhsr2t_maxcmdsn;
|
|
uint32_t bhsr2t_r2tsn;
|
|
uint32_t bhsr2t_buffer_offset;
|
|
uint32_t bhsr2t_desired_data_transfer_length;
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_r2t) == ISCSI_BHS_SIZE);
|
|
|
|
struct iscsi_bhs_nop_out {
|
|
uint8_t bhsno_opcode;
|
|
uint8_t bhsno_flags;
|
|
uint16_t bhsno_reserved;
|
|
uint8_t bhsno_total_ahs_len;
|
|
uint8_t bhsno_data_segment_len[3];
|
|
uint64_t bhsno_lun;
|
|
uint32_t bhsno_initiator_task_tag;
|
|
uint32_t bhsno_target_transfer_tag;
|
|
uint32_t bhsno_cmdsn;
|
|
uint32_t bhsno_expstatsn;
|
|
uint8_t bhsno_reserved2[16];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_nop_out) == ISCSI_BHS_SIZE);
|
|
|
|
struct iscsi_bhs_nop_in {
|
|
uint8_t bhsni_opcode;
|
|
uint8_t bhsni_flags;
|
|
uint16_t bhsni_reserved;
|
|
uint8_t bhsni_total_ahs_len;
|
|
uint8_t bhsni_data_segment_len[3];
|
|
uint64_t bhsni_lun;
|
|
uint32_t bhsni_initiator_task_tag;
|
|
uint32_t bhsni_target_transfer_tag;
|
|
uint32_t bhsni_statsn;
|
|
uint32_t bhsni_expcmdsn;
|
|
uint32_t bhsni_maxcmdsn;
|
|
uint8_t bhsno_reserved2[12];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_nop_in) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSLR_REASON_CLOSE_SESSION 0
|
|
#define BHSLR_REASON_CLOSE_CONNECTION 1
|
|
#define BHSLR_REASON_REMOVE_FOR_RECOVERY 2
|
|
|
|
struct iscsi_bhs_logout_request {
|
|
uint8_t bhslr_opcode;
|
|
uint8_t bhslr_reason;
|
|
uint16_t bhslr_reserved;
|
|
uint8_t bhslr_total_ahs_len;
|
|
uint8_t bhslr_data_segment_len[3];
|
|
uint64_t bhslr_reserved2;
|
|
uint32_t bhslr_initiator_task_tag;
|
|
uint16_t bhslr_cid;
|
|
uint16_t bhslr_reserved3;
|
|
uint32_t bhslr_cmdsn;
|
|
uint32_t bhslr_expstatsn;
|
|
uint8_t bhslr_reserved4[16];
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_logout_request) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSLR_RESPONSE_CLOSED_SUCCESSFULLY 0
|
|
#define BHSLR_RESPONSE_RECOVERY_NOT_SUPPORTED 2
|
|
|
|
struct iscsi_bhs_logout_response {
|
|
uint8_t bhslr_opcode;
|
|
uint8_t bhslr_flags;
|
|
uint8_t bhslr_response;
|
|
uint8_t bhslr_reserved;
|
|
uint8_t bhslr_total_ahs_len;
|
|
uint8_t bhslr_data_segment_len[3];
|
|
uint64_t bhslr_reserved2;
|
|
uint32_t bhslr_initiator_task_tag;
|
|
uint32_t bhslr_reserved3;
|
|
uint32_t bhslr_statsn;
|
|
uint32_t bhslr_expcmdsn;
|
|
uint32_t bhslr_maxcmdsn;
|
|
uint32_t bhslr_reserved4;
|
|
uint16_t bhslr_time2wait;
|
|
uint16_t bhslr_time2retain;
|
|
uint32_t bhslr_reserved5;
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_logout_response) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSAM_EVENT_TARGET_REQUESTS_LOGOUT 1
|
|
#define BHSAM_EVENT_TARGET_TERMINATES_CONNECTION 2
|
|
#define BHSAM_EVENT_TARGET_TERMINATES_SESSION 3
|
|
|
|
struct iscsi_bhs_asynchronous_message {
|
|
uint8_t bhsam_opcode;
|
|
uint8_t bhsam_flags;
|
|
uint16_t bhsam_reserved;
|
|
uint8_t bhsam_total_ahs_len;
|
|
uint8_t bhsam_data_segment_len[3];
|
|
uint64_t bhsam_lun;
|
|
uint32_t bhsam_0xffffffff;
|
|
uint32_t bhsam_reserved2;
|
|
uint32_t bhsam_statsn;
|
|
uint32_t bhsam_expcmdsn;
|
|
uint32_t bhsam_maxcmdsn;
|
|
uint8_t bhsam_async_event;
|
|
uint8_t bhsam_async_vcode;
|
|
uint16_t bhsam_parameter1;
|
|
uint16_t bhsam_parameter2;
|
|
uint16_t bhsam_parameter3;
|
|
uint32_t bhsam_reserved3;
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_asynchronous_message) == ISCSI_BHS_SIZE);
|
|
|
|
#define BHSSR_REASON_DATA_DIGEST_ERROR 0x02
|
|
#define BHSSR_PROTOCOL_ERROR 0x04
|
|
#define BHSSR_COMMAND_NOT_SUPPORTED 0x05
|
|
#define BHSSR_INVALID_PDU_FIELD 0x09
|
|
|
|
struct iscsi_bhs_reject {
|
|
uint8_t bhsr_opcode;
|
|
uint8_t bhsr_flags;
|
|
uint8_t bhsr_reason;
|
|
uint8_t bhsr_reserved;
|
|
uint8_t bhsr_total_ahs_len;
|
|
uint8_t bhsr_data_segment_len[3];
|
|
uint64_t bhsr_reserved2;
|
|
uint32_t bhsr_0xffffffff;
|
|
uint32_t bhsr_reserved3;
|
|
uint32_t bhsr_statsn;
|
|
uint32_t bhsr_expcmdsn;
|
|
uint32_t bhsr_maxcmdsn;
|
|
uint32_t bhsr_datasn_r2tsn;
|
|
uint32_t bhsr_reserved4;
|
|
uint32_t bhsr_reserved5;
|
|
};
|
|
CTASSERT(sizeof(struct iscsi_bhs_reject) == ISCSI_BHS_SIZE);
|
|
|
|
#endif /* !ISCSI_PROTO_H */
|