Add support for synchronous command timeout.

Default to 0 meaning no timeout.

Implement a test for iSCS to test what happens if we send a command
with CMDSN being higher than the target allows.
In this case we dont strictly know what will happen, just that what should
NOT happen is the target responding with success.
But we have to be prepared for any kind of failure, including a timeout,
scsi sense, or even iscsi reject or session failure.

Makefile.am

@@ -190,6 +190,7 @@ bin_iscsi_test_cu_SOURCES = test-tool/iscsi-test-cu.c \
 	test-tool/test_inquiry_evpd.c \
 	test-tool/test_inquiry_supported_vpd.c \
 	test-tool/test_inquiry_mandatory_vpd_sbc.c \
+	test-tool/test_iscsi_cmdsn_invalid.c \
 	test-tool/test_mandatory_sbc.c \
 	test-tool/test_nomedia_sbc.c \
 	test-tool/test_orwrite_simple.c \

include/iscsi-private.h

@@ -131,7 +131,8 @@ struct iscsi_context {
 	int reallocs;
 	int frees;
 
-	time_t last_reconnect;	
+	time_t last_reconnect;
+	int scsi_timeout;
 };
 
 #define ISCSI_PDU_IMMEDIATE		       0x40
@@ -224,6 +225,7 @@ struct iscsi_pdu {
 	struct iscsi_data indata;
 
 	struct iscsi_scsi_cbdata scsi_cbdata;
+	time_t scsi_timeout;
 };
 
 struct iscsi_pdu *iscsi_allocate_pdu(struct iscsi_context *iscsi,
@@ -326,6 +328,8 @@ iscsi_serial32_compare(uint32_t s1, uint32_t s2);
 u_int32_t
 iscsi_itt_post_increment(struct iscsi_context *iscsi);
 
+void iscsi_timeout_scan(struct iscsi_context *iscsi);
+
 #ifdef __cplusplus
 }
 #endif

include/iscsi.h

@@ -70,11 +70,18 @@ EXTERN int iscsi_service(struct iscsi_context *iscsi, int revents);
  */
 EXTERN int iscsi_queue_length(struct iscsi_context *iscsi);
 
+/*
+ * Set the timeout in seconds after which a synchronous SCSI command
+ * will timeout.
+ * Default is 0 == no timeout.
+ */
+EXTERN int iscsi_set_timeout(struct iscsi_context *iscsi, int timeout);
+
 /*
  * To set tcp keepalive for the session.
  * Only options supported by given platform (if any) are set.
  */
-int iscsi_set_tcp_keepalive(struct iscsi_context *iscsi, int idle, int count, int interval);
+EXTERN int iscsi_set_tcp_keepalive(struct iscsi_context *iscsi, int idle, int count, int interval);
 
 struct iscsi_url {
        char portal[MAX_STRING_SIZE+1];
@@ -268,7 +275,8 @@ enum scsi_status {
 	SCSI_STATUS_RESERVATION_CONFLICT = 0x18,
 	SCSI_STATUS_REDIRECT             = 0x101,
 	SCSI_STATUS_CANCELLED            = 0x0f000000,
-	SCSI_STATUS_ERROR                = 0x0f000001
+	SCSI_STATUS_ERROR                = 0x0f000001,
+	SCSI_STATUS_TIMEOUT              = 0x0f000002
 };
 
 

lib/init.c

@@ -534,3 +534,9 @@ iscsi_set_initial_r2t(struct iscsi_context *iscsi, enum iscsi_initial_r2t initia
 	return 0;
 }
 
+int
+iscsi_set_timeout(struct iscsi_context *iscsi, int timeout)
+{
+	iscsi->scsi_timeout = timeout;
+	return 0;
+}

lib/iscsi-command.c

@@ -148,6 +148,45 @@ iscsi_send_data_out(struct iscsi_context *iscsi, struct iscsi_pdu *cmd_pdu,
 	return 0;
 }
 
+void
+iscsi_timeout_scan(struct iscsi_context *iscsi)
+{
+	struct iscsi_pdu *pdu;
+	struct iscsi_pdu *next_pdu;
+	time_t t = time(NULL);
+
+	for (pdu = iscsi->waitpdu; pdu; pdu = next_pdu) {
+		struct iscsi_scsi_cbdata *scsi_cbdata;
+		struct scsi_task *task;
+
+		next_pdu = pdu->next;
+
+		if (pdu->scsi_timeout == 0) {
+			/* no timeout for this pdu */
+			continue;
+		}
+		if (t < pdu->scsi_timeout) {
+			/* not expired yet */
+			continue;
+		}
+		if (pdu->outdata.data[0] != ISCSI_PDU_SCSI_REQUEST) {
+			continue;
+		}
+
+		scsi_cbdata = &pdu->scsi_cbdata;
+		task = scsi_cbdata->task;
+
+		SLIST_REMOVE(&iscsi->waitpdu, pdu);
+		pdu->callback(iscsi, SCSI_STATUS_TIMEOUT,
+				task, pdu->private_data);
+		iscsi_set_error(iscsi, "SCSI command timed out");
+
+		/* task is freed by the sync caller */
+		task->status = SCSI_STATUS_TIMEOUT;
+	}
+}
+
+
 /* Using 'struct iscsi_data *d' for data-out is optional
  * and will be converted into a one element data-out iovector.
  */
@@ -1662,3 +1701,4 @@ iscsi_scsi_cancel_all_tasks(struct iscsi_context *iscsi)
 		iscsi_free_pdu(iscsi, pdu);
 	}
 }
+

lib/libiscsi.def

@@ -63,6 +63,7 @@ iscsi_report_supported_opcodes_task
 iscsi_reconnect
 iscsi_set_noautoreconnect
 iscsi_set_reconnect_max_retries
+iscsi_set_timeout
 iscsi_reportluns_sync
 iscsi_reportluns_task
 iscsi_scsi_cancel_all_tasks

lib/libiscsi.syms

@@ -61,6 +61,7 @@ iscsi_report_supported_opcodes_task
 iscsi_reconnect
 iscsi_set_noautoreconnect
 iscsi_set_reconnect_max_retries
+iscsi_set_timeout
 iscsi_reportluns_sync
 iscsi_reportluns_task
 iscsi_scsi_cancel_all_tasks

lib/socket.c

@@ -61,6 +61,7 @@
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <time.h>
 #include "scsi-lowlevel.h"
 #include "iscsi.h"
 #include "iscsi-private.h"
@@ -73,7 +74,13 @@ iscsi_add_to_outqueue(struct iscsi_context *iscsi, struct iscsi_pdu *pdu)
 {
 	struct iscsi_pdu *current = iscsi->outqueue;
 	struct iscsi_pdu *last = NULL;
-	
+
+	if (iscsi->scsi_timeout > 0) {
+		pdu->scsi_timeout = time(NULL) + iscsi->scsi_timeout;
+	} else {
+		pdu->scsi_timeout = 0;
+	}
+
 	if (iscsi->outqueue == NULL) {
 		iscsi->outqueue = pdu;
 		pdu->next = NULL;

lib/sync.c

@@ -34,6 +34,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include "iscsi.h"
 #include "iscsi-private.h"
 #include "scsi-lowlevel.h"
@@ -60,7 +61,7 @@ event_loop(struct iscsi_context *iscsi, struct iscsi_sync_state *state)
 			return;
 		}
 		if (ret == 0) {
-			/* poll timedout, try again */
+			iscsi_timeout_scan(iscsi);
 			continue;
 		}
 		if (iscsi_service(iscsi, pfd.revents) < 0) {

test-tool/iscsi-support.c

@@ -1390,6 +1390,12 @@ testunitready(struct iscsi_context *iscsi, int lun)
 			iscsi_get_error(iscsi));
 		return -1;
 	}
+	if (task->status == SCSI_STATUS_TIMEOUT) {
+		logging(LOG_NORMAL,
+			"TESTUNITREADY timed out");
+		scsi_free_scsi_task(task);
+		return -1;
+	}
 	if (task->status != SCSI_STATUS_GOOD) {
 		logging(LOG_NORMAL,
 			"[FAILED] TESTUNITREADY command: failed with sense. %s",

test-tool/iscsi-test-cu.c

@@ -61,312 +61,298 @@ int (*real_iscsi_queue_pdu)(struct iscsi_context *iscsi, struct iscsi_pdu *pdu);
  *
  *****************************************************************/
 static CU_TestInfo tests_get_lba_status[] = {
-	{ (char *)"testGetLBAStatusSimple", test_get_lba_status_simple },
-	{ (char *)"testGetLBAStatusBeyondEol", test_get_lba_status_beyond_eol },
+	{ (char *)"GetLBAStatusSimple", test_get_lba_status_simple },
+	{ (char *)"GetLBAStatusBeyondEol", test_get_lba_status_beyond_eol },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_inquiry[] = {
-	{ (char *)"testInquiryStandard", test_inquiry_standard },
-	{ (char *)"testInquiryAllocLength", test_inquiry_alloc_length},
-	{ (char *)"testInquiryEVPD", test_inquiry_evpd},
-	{ (char *)"testInquirySupportedVPD", test_inquiry_supported_vpd},
-	{ (char *)"testInquiryMandatoryVPDSBC", test_inquiry_mandatory_vpd_sbc},
+	{ (char *)"InquiryStandard", test_inquiry_standard },
+	{ (char *)"InquiryAllocLength", test_inquiry_alloc_length},
+	{ (char *)"InquiryEVPD", test_inquiry_evpd},
+	{ (char *)"InquirySupportedVPD", test_inquiry_supported_vpd},
+	{ (char *)"InquiryMandatoryVPDSBC", test_inquiry_mandatory_vpd_sbc},
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_mandatory[] = {
-	{ (char *)"testMandatorySBC", test_mandatory_sbc },
+	{ (char *)"MandatorySBC", test_mandatory_sbc },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_nomedia[] = {
-	{ (char *)"testNoMediaSBC", test_nomedia_sbc },
+	{ (char *)"NoMediaSBC", test_nomedia_sbc },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_orwrite[] = {
-	{ (char *)"testOrWriteSimple", test_orwrite_simple },
-	{ (char *)"testOrWriteBeyondEol", test_orwrite_beyond_eol },
-	{ (char *)"testOrWriteZeroBlocks", test_orwrite_0blocks },
-	{ (char *)"testOrWriteProtect", test_orwrite_wrprotect },
-	{ (char *)"testOrWriteFlags", test_orwrite_flags },
-	{ (char *)"testOrWriteVerify", test_orwrite_verify },
+	{ (char *)"OrWriteSimple", test_orwrite_simple },
+	{ (char *)"OrWriteBeyondEol", test_orwrite_beyond_eol },
+	{ (char *)"OrWriteZeroBlocks", test_orwrite_0blocks },
+	{ (char *)"OrWriteProtect", test_orwrite_wrprotect },
+	{ (char *)"OrWriteFlags", test_orwrite_flags },
+	{ (char *)"OrWriteVerify", test_orwrite_verify },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_prefetch10[] = {
-	{ (char *)"testPrefetch10Simple", test_prefetch10_simple },
-	{ (char *)"testPrefetch10BeyondEol", test_prefetch10_beyond_eol },
-	{ (char *)"testPrefetch10ZeroBlocks", test_prefetch10_0blocks },
-	{ (char *)"testPrefetch10Flags", test_prefetch10_flags },
+	{ (char *)"Prefetch10Simple", test_prefetch10_simple },
+	{ (char *)"Prefetch10BeyondEol", test_prefetch10_beyond_eol },
+	{ (char *)"Prefetch10ZeroBlocks", test_prefetch10_0blocks },
+	{ (char *)"Prefetch10Flags", test_prefetch10_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_prefetch16[] = {
-	{ (char *)"testPrefetch16Simple", test_prefetch16_simple },
-	{ (char *)"testPrefetch16BeyondEol", test_prefetch16_beyond_eol },
-	{ (char *)"testPrefetch16ZeroBlocks", test_prefetch16_0blocks },
-	{ (char *)"testPrefetch16Flags", test_prefetch16_flags },
+	{ (char *)"Prefetch16Simple", test_prefetch16_simple },
+	{ (char *)"Prefetch16BeyondEol", test_prefetch16_beyond_eol },
+	{ (char *)"Prefetch16ZeroBlocks", test_prefetch16_0blocks },
+	{ (char *)"Prefetch16Flags", test_prefetch16_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_preventallow[] = {
-	{ (char *)"testPreventAllowSimple", test_preventallow_simple },
-	{ (char *)"testPreventAllowEject", test_preventallow_eject },
-	{ (char *)"testPreventAllowITNexusLoss", test_preventallow_itnexus_loss },
-	{ (char *)"testPreventAllowLogout", test_preventallow_logout },
-	{ (char *)"testPreventAllowWarmReset", test_preventallow_warm_reset },
-	{ (char *)"testPreventAllowColdReset", test_preventallow_cold_reset },
-	{ (char *)"testPreventAllowLUNReset", test_preventallow_lun_reset },
-	{ (char *)"testPreventAllow2ITNexuses", test_preventallow_2_itnexuses },
+	{ (char *)"PreventAllowSimple", test_preventallow_simple },
+	{ (char *)"PreventAllowEject", test_preventallow_eject },
+	{ (char *)"PreventAllowITNexusLoss", test_preventallow_itnexus_loss },
+	{ (char *)"PreventAllowLogout", test_preventallow_logout },
+	{ (char *)"PreventAllowWarmReset", test_preventallow_warm_reset },
+	{ (char *)"PreventAllowColdReset", test_preventallow_cold_reset },
+	{ (char *)"PreventAllowLUNReset", test_preventallow_lun_reset },
+	{ (char *)"PreventAllow2ITNexuses", test_preventallow_2_itnexuses },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_prin_read_keys[] = {
-	{ (char *)"testPrinReadKeysSimple", test_prin_read_keys_simple },
+	{ (char *)"PrinReadKeysSimple", test_prin_read_keys_simple },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_prout_register[] = {
-	{ (char *)"testProutRegisterSimple", test_prout_register_simple },
+	{ (char *)"ProutRegisterSimple", test_prout_register_simple },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_prout_reserve[] = {
-	{ (char *)"testProutReserveSimple",
+	{ (char *)"ProutReserveSimple",
 	  test_prout_reserve_simple },
-	{ (char *)"testProutReserveAccessEA",
+	{ (char *)"ProutReserveAccessEA",
 	  test_prout_reserve_access_ea },
-	{ (char *)"testProutReserveAccessWE",
+	{ (char *)"ProutReserveAccessWE",
 	  test_prout_reserve_access_we },
-	{ (char *)"testProutReserveAccessEARO",
+	{ (char *)"ProutReserveAccessEARO",
 	  test_prout_reserve_access_earo },
-	{ (char *)"testProutReserveAccessWERO",
+	{ (char *)"ProutReserveAccessWERO",
 	  test_prout_reserve_access_wero },
-	{ (char *)"testProutReserveAccessEAAR",
+	{ (char *)"ProutReserveAccessEAAR",
 	  test_prout_reserve_access_eaar },
-	{ (char *)"testProutReserveAccessWEAR",
+	{ (char *)"ProutReserveAccessWEAR",
 	  test_prout_reserve_access_wear },
-	{ (char *)"testProutReserveOwnershipEA",
+	{ (char *)"ProutReserveOwnershipEA",
 	  test_prout_reserve_ownership_ea },
-	{ (char *)"testProutReserveOwnershipWE",
+	{ (char *)"ProutReserveOwnershipWE",
 	  test_prout_reserve_ownership_we },
-	{ (char *)"testProutReserveOwnershipEARO",
+	{ (char *)"ProutReserveOwnershipEARO",
 	  test_prout_reserve_ownership_earo },
-	{ (char *)"testProutReserveOwnershipWERO",
+	{ (char *)"ProutReserveOwnershipWERO",
 	  test_prout_reserve_ownership_wero },
-	{ (char *)"testProutReserveOwnershipEAAR",
+	{ (char *)"ProutReserveOwnershipEAAR",
 	  test_prout_reserve_ownership_eaar },
-	{ (char *)"testProutReserveOwnershipWEAR",
+	{ (char *)"ProutReserveOwnershipWEAR",
 	  test_prout_reserve_ownership_wear },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_prin_serviceaction_range[] = {
-	{ (char *)"testPrinServiceactionRange", test_prin_serviceaction_range },
+	{ (char *)"PrinServiceactionRange", test_prin_serviceaction_range },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_read6[] = {
-	{ (char *)"testRead6Simple", test_read6_simple },
-	{ (char *)"testRead6BeyondEol", test_read6_beyond_eol },
-	{ (char *)"testRead6ZeroBlocks", test_read6_0blocks },
+	{ (char *)"Read6Simple", test_read6_simple },
+	{ (char *)"Read6BeyondEol", test_read6_beyond_eol },
+	{ (char *)"Read6ZeroBlocks", test_read6_0blocks },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_read10[] = {
-	{ (char *)"testRead10Simple", test_read10_simple },
-	{ (char *)"testRead10BeyondEol", test_read10_beyond_eol },
-	{ (char *)"testRead10ZeroBlocks", test_read10_0blocks },
-	{ (char *)"testRead10ReadProtect", test_read10_rdprotect },
-	{ (char *)"testRead10Flags", test_read10_flags },
+	{ (char *)"Read10Simple", test_read10_simple },
+	{ (char *)"Read10BeyondEol", test_read10_beyond_eol },
+	{ (char *)"Read10ZeroBlocks", test_read10_0blocks },
+	{ (char *)"Read10ReadProtect", test_read10_rdprotect },
+	{ (char *)"Read10Flags", test_read10_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_read12[] = {
-	{ (char *)"testRead12Simple", test_read12_simple },
-	{ (char *)"testRead12BeyondEol", test_read12_beyond_eol },
-	{ (char *)"testRead12ZeroBlocks", test_read12_0blocks },
-	{ (char *)"testRead12ReadProtect", test_read12_rdprotect },
-	{ (char *)"testRead12Flags", test_read12_flags },
+	{ (char *)"Read12Simple", test_read12_simple },
+	{ (char *)"Read12BeyondEol", test_read12_beyond_eol },
+	{ (char *)"Read12ZeroBlocks", test_read12_0blocks },
+	{ (char *)"Read12ReadProtect", test_read12_rdprotect },
+	{ (char *)"Read12Flags", test_read12_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_read16[] = {
-	{ (char *)"testRead16Simple", test_read16_simple },
-	{ (char *)"testRead16BeyondEol", test_read16_beyond_eol },
-	{ (char *)"testRead16ZeroBlocks", test_read16_0blocks },
-	{ (char *)"testRead16ReadProtect", test_read16_rdprotect },
-	{ (char *)"testRead16Flags", test_read16_flags },
+	{ (char *)"Read16Simple", test_read16_simple },
+	{ (char *)"Read16BeyondEol", test_read16_beyond_eol },
+	{ (char *)"Read16ZeroBlocks", test_read16_0blocks },
+	{ (char *)"Read16ReadProtect", test_read16_rdprotect },
+	{ (char *)"Read16Flags", test_read16_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_readcapacity10[] = {
-	{ (char *)"testReadCapacity10Simple", test_readcapacity10_simple },
+	{ (char *)"ReadCapacity10Simple", test_readcapacity10_simple },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_readcapacity16[] = {
-	{ (char *)"testReadCapacity16Simple", test_readcapacity16_simple },
-	{ (char *)"testReadCapacity16Alloclen", test_readcapacity16_alloclen },
+	{ (char *)"ReadCapacity16Simple", test_readcapacity16_simple },
+	{ (char *)"ReadCapacity16Alloclen", test_readcapacity16_alloclen },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_readonly[] = {
-	{ (char *)"testReadOnlySBC", test_readonly_sbc },
+	{ (char *)"ReadOnlySBC", test_readonly_sbc },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_reserve6[] = {
-	{ (char *)"testReserve6Simple", test_reserve6_simple },
-	{ (char *)"testReserve6_2Initiators", test_reserve6_2initiators },
-	{ (char *)"testReserve6Logout", test_reserve6_logout },
-	{ (char *)"testReserve6ITNexusLoss", test_reserve6_itnexus_loss },
-	{ (char *)"testReserve6TargetColdReset", test_reserve6_target_cold_reset },
-	{ (char *)"testReserve6TargetWarmReset", test_reserve6_target_warm_reset },
-	{ (char *)"testReserve6LUNReset", test_reserve6_lun_reset },
+	{ (char *)"Reserve6Simple", test_reserve6_simple },
+	{ (char *)"Reserve6_2Initiators", test_reserve6_2initiators },
+	{ (char *)"Reserve6Logout", test_reserve6_logout },
+	{ (char *)"Reserve6ITNexusLoss", test_reserve6_itnexus_loss },
+	{ (char *)"Reserve6TargetColdReset", test_reserve6_target_cold_reset },
+	{ (char *)"Reserve6TargetWarmReset", test_reserve6_target_warm_reset },
+	{ (char *)"Reserve6LUNReset", test_reserve6_lun_reset },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_testunitready[] = {
-	{ (char *)"testTurSimple", test_testunitready_simple },
+	{ (char *)"TurSimple", test_testunitready_simple },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_startstopunit[] = {
-	{ (char *)"testStartStopUnitSimple", test_startstopunit_simple },
-	{ (char *)"testStartStopUnitPwrCnd", test_startstopunit_pwrcnd },
-	{ (char *)"testStartStopUnitNoLoej", test_startstopunit_noloej },
+	{ (char *)"StartStopUnitSimple", test_startstopunit_simple },
+	{ (char *)"StartStopUnitPwrCnd", test_startstopunit_pwrcnd },
+	{ (char *)"StartStopUnitNoLoej", test_startstopunit_noloej },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_unmap[] = {
-	{ (char *)"testUnmapSimple", test_unmap_simple },
-	{ (char *)"testUnmapZeroBlocks", test_unmap_0blocks },
+	{ (char *)"UnmapSimple", test_unmap_simple },
+	{ (char *)"UnmapZeroBlocks", test_unmap_0blocks },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_verify10[] = {
-	{ (char *)"testVerify10Simple", test_verify10_simple },
-	{ (char *)"testVerify10BeyondEol", test_verify10_beyond_eol },
-	{ (char *)"testVerify10ZeroBlocks", test_verify10_0blocks },
-	{ (char *)"testVerify10VerifyProtect", test_verify10_vrprotect },
-	{ (char *)"testVerify10Flags", test_verify10_flags },
-	{ (char *)"testVerify10mismatch", test_verify10_mismatch },
-	{ (char *)"testVerify10mismatch_no_cmp", test_verify10_mismatch_no_cmp },
+	{ (char *)"Verify10Simple", test_verify10_simple },
+	{ (char *)"Verify10BeyondEol", test_verify10_beyond_eol },
+	{ (char *)"Verify10ZeroBlocks", test_verify10_0blocks },
+	{ (char *)"Verify10VerifyProtect", test_verify10_vrprotect },
+	{ (char *)"Verify10Flags", test_verify10_flags },
+	{ (char *)"Verify10mismatch", test_verify10_mismatch },
+	{ (char *)"Verify10mismatch_no_cmp", test_verify10_mismatch_no_cmp },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_verify12[] = {
-	{ (char *)"testVerify12Simple", test_verify12_simple },
-	{ (char *)"testVerify12BeyondEol", test_verify12_beyond_eol },
-	{ (char *)"testVerify12ZeroBlocks", test_verify12_0blocks },
-	{ (char *)"testVerify12VerifyProtect", test_verify12_vrprotect },
-	{ (char *)"testVerify12Flags", test_verify12_flags },
-	{ (char *)"testVerify12mismatch", test_verify12_mismatch },
-	{ (char *)"testVerify12mismatch_no_cmp", test_verify12_mismatch_no_cmp },
+	{ (char *)"Verify12Simple", test_verify12_simple },
+	{ (char *)"Verify12BeyondEol", test_verify12_beyond_eol },
+	{ (char *)"Verify12ZeroBlocks", test_verify12_0blocks },
+	{ (char *)"Verify12VerifyProtect", test_verify12_vrprotect },
+	{ (char *)"Verify12Flags", test_verify12_flags },
+	{ (char *)"Verify12mismatch", test_verify12_mismatch },
+	{ (char *)"Verify12mismatch_no_cmp", test_verify12_mismatch_no_cmp },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_verify16[] = {
-	{ (char *)"testVerify16Simple", test_verify16_simple },
-	{ (char *)"testVerify16BeyondEol", test_verify16_beyond_eol },
-	{ (char *)"testVerify16ZeroBlocks", test_verify16_0blocks },
-	{ (char *)"testVerify16VerifyProtect", test_verify16_vrprotect },
-	{ (char *)"testVerify16Flags", test_verify16_flags },
-	{ (char *)"testVerify16mismatch", test_verify16_mismatch },
-	{ (char *)"testVerify16mismatch_no_cmp", test_verify16_mismatch_no_cmp },
+	{ (char *)"Verify16Simple", test_verify16_simple },
+	{ (char *)"Verify16BeyondEol", test_verify16_beyond_eol },
+	{ (char *)"Verify16ZeroBlocks", test_verify16_0blocks },
+	{ (char *)"Verify16VerifyProtect", test_verify16_vrprotect },
+	{ (char *)"Verify16Flags", test_verify16_flags },
+	{ (char *)"Verify16mismatch", test_verify16_mismatch },
+	{ (char *)"Verify16mismatch_no_cmp", test_verify16_mismatch_no_cmp },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_write10[] = {
-	{ (char *)"testWrite10Simple", test_write10_simple },
-	{ (char *)"testWrite10BeyondEol", test_write10_beyond_eol },
-	{ (char *)"testWrite10ZeroBlocks", test_write10_0blocks },
-	{ (char *)"testWrite10WriteProtect", test_write10_wrprotect },
-	{ (char *)"testWrite10Flags", test_write10_flags },
+	{ (char *)"Write10Simple", test_write10_simple },
+	{ (char *)"Write10BeyondEol", test_write10_beyond_eol },
+	{ (char *)"Write10ZeroBlocks", test_write10_0blocks },
+	{ (char *)"Write10WriteProtect", test_write10_wrprotect },
+	{ (char *)"Write10Flags", test_write10_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_write12[] = {
-	{ (char *)"testWrite12Simple", test_write12_simple },
-	{ (char *)"testWrite12BeyondEol", test_write12_beyond_eol },
-	{ (char *)"testWrite12ZeroBlocks", test_write12_0blocks },
-	{ (char *)"testWrite12WriteProtect", test_write12_wrprotect },
-	{ (char *)"testWrite12Flags", test_write12_flags },
+	{ (char *)"Write12Simple", test_write12_simple },
+	{ (char *)"Write12BeyondEol", test_write12_beyond_eol },
+	{ (char *)"Write12ZeroBlocks", test_write12_0blocks },
+	{ (char *)"Write12WriteProtect", test_write12_wrprotect },
+	{ (char *)"Write12Flags", test_write12_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_write16[] = {
-	{ (char *)"testWrite16Simple", test_write16_simple },
-	{ (char *)"testWrite16BeyondEol", test_write16_beyond_eol },
-	{ (char *)"testWrite16ZeroBlocks", test_write16_0blocks },
-	{ (char *)"testWrite16WriteProtect", test_write16_wrprotect },
-	{ (char *)"testWrite16Flags", test_write16_flags },
+	{ (char *)"Write16Simple", test_write16_simple },
+	{ (char *)"Write16BeyondEol", test_write16_beyond_eol },
+	{ (char *)"Write16ZeroBlocks", test_write16_0blocks },
+	{ (char *)"Write16WriteProtect", test_write16_wrprotect },
+	{ (char *)"Write16Flags", test_write16_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_writesame10[] = {
-	{ (char *)"testWriteSame10Simple", test_writesame10_simple },
-	{ (char *)"testWriteSame10BeyondEol", test_writesame10_beyond_eol },
-	{ (char *)"testWriteSame10ZeroBlocks", test_writesame10_0blocks },
-	{ (char *)"testWriteSame10WriteProtect", test_writesame10_wrprotect },
-	{ (char *)"testWriteSame10Unmap", test_writesame10_unmap },
-	{ (char *)"testWriteSame10UnmapUnaligned", test_writesame10_unmap_unaligned },
-	{ (char *)"testWriteSame10UnmapUntilEnd", test_writesame10_unmap_until_end },
+	{ (char *)"WriteSame10Simple", test_writesame10_simple },
+	{ (char *)"WriteSame10BeyondEol", test_writesame10_beyond_eol },
+	{ (char *)"WriteSame10ZeroBlocks", test_writesame10_0blocks },
+	{ (char *)"WriteSame10WriteProtect", test_writesame10_wrprotect },
+	{ (char *)"WriteSame10Unmap", test_writesame10_unmap },
+	{ (char *)"WriteSame10UnmapUnaligned", test_writesame10_unmap_unaligned },
+	{ (char *)"WriteSame10UnmapUntilEnd", test_writesame10_unmap_until_end },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_writesame16[] = {
-	{ (char *)"testWriteSame16Simple", test_writesame16_simple },
-	{ (char *)"testWriteSame16BeyondEol", test_writesame16_beyond_eol },
-	{ (char *)"testWriteSame16ZeroBlocks", test_writesame16_0blocks },
-	{ (char *)"testWriteSame16WriteProtect", test_writesame16_wrprotect },
-	{ (char *)"testWriteSame16Unmap", test_writesame16_unmap },
-	{ (char *)"testWriteSame16UnmapUnaligned", test_writesame16_unmap_unaligned },
-	{ (char *)"testWriteSame16UnmapUntilEnd", test_writesame16_unmap_until_end },
+	{ (char *)"WriteSame16Simple", test_writesame16_simple },
+	{ (char *)"WriteSame16BeyondEol", test_writesame16_beyond_eol },
+	{ (char *)"WriteSame16ZeroBlocks", test_writesame16_0blocks },
+	{ (char *)"WriteSame16WriteProtect", test_writesame16_wrprotect },
+	{ (char *)"WriteSame16Unmap", test_writesame16_unmap },
+	{ (char *)"WriteSame16UnmapUnaligned", test_writesame16_unmap_unaligned },
+	{ (char *)"WriteSame16UnmapUntilEnd", test_writesame16_unmap_until_end },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_writeverify10[] = {
-	{ (char *)"testWriteVerify10Simple", test_writeverify10_simple },
-	{ (char *)"testWriteVerify10BeyondEol", test_writeverify10_beyond_eol },
-	{ (char *)"testWriteVerify10ZeroBlocks", test_writeverify10_0blocks },
-	{ (char *)"testWriteVerify10WriteProtect", test_writeverify10_wrprotect },
-	{ (char *)"testWriteVerify10Flags", test_writeverify10_flags },
+	{ (char *)"WriteVerify10Simple", test_writeverify10_simple },
+	{ (char *)"WriteVerify10BeyondEol", test_writeverify10_beyond_eol },
+	{ (char *)"WriteVerify10ZeroBlocks", test_writeverify10_0blocks },
+	{ (char *)"WriteVerify10WriteProtect", test_writeverify10_wrprotect },
+	{ (char *)"WriteVerify10Flags", test_writeverify10_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_writeverify12[] = {
-	{ (char *)"testWriteVerify12Simple", test_writeverify12_simple },
-	{ (char *)"testWriteVerify12BeyondEol", test_writeverify12_beyond_eol },
-	{ (char *)"testWriteVerify12ZeroBlocks", test_writeverify12_0blocks },
-	{ (char *)"testWriteVerify12WriteProtect", test_writeverify12_wrprotect },
-	{ (char *)"testWriteVerify12Flags", test_writeverify12_flags },
+	{ (char *)"WriteVerify12Simple", test_writeverify12_simple },
+	{ (char *)"WriteVerify12BeyondEol", test_writeverify12_beyond_eol },
+	{ (char *)"WriteVerify12ZeroBlocks", test_writeverify12_0blocks },
+	{ (char *)"WriteVerify12WriteProtect", test_writeverify12_wrprotect },
+	{ (char *)"WriteVerify12Flags", test_writeverify12_flags },
 	CU_TEST_INFO_NULL
 };
 
 static CU_TestInfo tests_writeverify16[] = {
-	{ (char *)"testWriteVerify16Simple", test_writeverify16_simple },
-	{ (char *)"testWriteVerify16BeyondEol", test_writeverify16_beyond_eol },
-	{ (char *)"testWriteVerify16ZeroBlocks", test_writeverify16_0blocks },
-	{ (char *)"testWriteVerify16WriteProtect", test_writeverify16_wrprotect },
-	{ (char *)"testWriteVerify16Flags", test_writeverify16_flags },
-	CU_TEST_INFO_NULL
-};
-
-static CU_TestInfo tests_iscsiresiduals[] = {
-	{ (char *)"testRead10Invalid", test_read10_invalid },
-	{ (char *)"testRead10Residuals", test_read10_residuals },
-	{ (char *)"testRead12Residuals", test_read12_residuals },
-	{ (char *)"testRead16Residuals", test_read16_residuals },
-	{ (char *)"testWrite10Residuals", test_write10_residuals },
-	{ (char *)"testWrite12Residuals", test_write12_residuals },
-	{ (char *)"testWrite16Residuals", test_write16_residuals },
-	{ (char *)"testWriteVerify10Residuals", test_writeverify10_residuals },
-	{ (char *)"testWriteVerify12Residuals", test_writeverify12_residuals },
-	{ (char *)"testWriteVerify16Residuals", test_writeverify16_residuals },
+	{ (char *)"WriteVerify16Simple", test_writeverify16_simple },
+	{ (char *)"WriteVerify16BeyondEol", test_writeverify16_beyond_eol },
+	{ (char *)"WriteVerify16ZeroBlocks", test_writeverify16_0blocks },
+	{ (char *)"WriteVerify16WriteProtect", test_writeverify16_wrprotect },
+	{ (char *)"WriteVerify16Flags", test_writeverify16_flags },
 	CU_TEST_INFO_NULL
 };
 
@@ -415,7 +401,7 @@ static CU_SuiteInfo scsi_suites[] = {
 	  tests_reserve6 },
 	{ (char *)"StartStopUnit", test_setup, test_teardown,
 	  tests_startstopunit },
-	{ (char *)"TestUnitReady", test_setup, test_teardown,
+	{ (char *)"UnitReady", test_setup, test_teardown,
 	  tests_testunitready },
 	{ (char *)"Unmap", test_setup, test_teardown,
 	  tests_unmap },
@@ -444,10 +430,31 @@ static CU_SuiteInfo scsi_suites[] = {
 	CU_SUITE_INFO_NULL
 };
 
+static CU_TestInfo tests_iscsi_cmdsn[] = {
+	{ (char *)"iSCSICmdSnInvalid", test_iscsi_cmdsn_invalid },
+	CU_TEST_INFO_NULL
+};
+
+static CU_TestInfo tests_iscsi_residuals[] = {
+	{ (char *)"Read10Invalid", test_read10_invalid },
+	{ (char *)"Read10Residuals", test_read10_residuals },
+	{ (char *)"Read12Residuals", test_read12_residuals },
+	{ (char *)"Read16Residuals", test_read16_residuals },
+	{ (char *)"Write10Residuals", test_write10_residuals },
+	{ (char *)"Write12Residuals", test_write12_residuals },
+	{ (char *)"Write16Residuals", test_write16_residuals },
+	{ (char *)"WriteVerify10Residuals", test_writeverify10_residuals },
+	{ (char *)"WriteVerify12Residuals", test_writeverify12_residuals },
+	{ (char *)"WriteVerify16Residuals", test_writeverify16_residuals },
+	CU_TEST_INFO_NULL
+};
+
 /* iSCSI protocol tests */
 static CU_SuiteInfo iscsi_suites[] = {
+	{ (char *)"iSCSIcmdsn", test_setup, test_teardown,
+	  tests_iscsi_cmdsn },
 	{ (char *)"iSCSIResiduals", test_setup, test_teardown,
-	  tests_iscsiresiduals },
+	  tests_iscsi_residuals },
 	CU_SUITE_INFO_NULL
 };
 
@@ -521,8 +528,10 @@ static CU_SuiteInfo all_suites[] = {
 	  tests_writeverify12 },
 	{ (char *)"WriteVerify16", test_setup, test_teardown,
 	  tests_writeverify16 },
+	{ (char *)"iSCSIcmdsn", test_setup, test_teardown,
+	  tests_iscsi_cmdsn },
 	{ (char *)"iSCSIResiduals", test_setup, test_teardown,
-	  tests_iscsiresiduals },
+	  tests_iscsi_residuals },
 	CU_SUITE_INFO_NULL
 };
 

test-tool/iscsi-test-cu.h

@@ -49,6 +49,8 @@ void test_inquiry_evpd(void);
 void test_inquiry_supported_vpd(void);
 void test_inquiry_mandatory_vpd_sbc(void);
 
+void test_iscsi_cmdsn_invalid(void);
+
 void test_mandatory_sbc(void);
 
 void test_nomedia_sbc(void);

test-tool/test_iscsi_cmdsn_invalid.c

@@ -0,0 +1,69 @@
+/* 
+   Copyright (C) 2013 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
+   
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+   
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <arpa/inet.h>
+#include <CUnit/CUnit.h>
+
+#include "iscsi.h"
+#include "iscsi-private.h"
+#include "scsi-lowlevel.h"
+#include "iscsi-test-cu.h"
+
+static int change_cmdsn;
+
+static int my_iscsi_queue_pdu(struct iscsi_context *iscsi, struct iscsi_pdu *pdu)
+{
+	switch (change_cmdsn) {
+	case 1:
+		/* change the cmdsn so it becomes too big */
+		*(uint32_t *)&pdu->outdata.data[24] = htonl(iscsi->maxcmdsn + 1);
+		break;
+	case 2:
+		/* change the cmdsn so it becomes too small */
+		*(uint32_t *)&pdu->outdata.data[24] = 0;
+		break;
+	}
+
+	change_cmdsn = 0;	
+	return 0;
+}
+
+void test_iscsi_cmdsn_invalid(void)
+{ 
+	int ret;
+
+	logging(LOG_VERBOSE, LOG_BLANK_LINE);
+	logging(LOG_VERBOSE, "Test sending invalid iSCSI CMDSN");
+	logging(LOG_VERBOSE, "CMDSN MUST be in the range EXPCMDSN and MAXCMDSN");
+
+	logging(LOG_VERBOSE, "Test that a CMDSN > MAXCMDSN is an error");
+	logging(LOG_VERBOSE, "Send a TESTUNITREADY with CMDSN == MAXCMDSN+1");
+
+	iscsic->use_immediate_data = ISCSI_IMMEDIATE_DATA_NO;
+	iscsic->target_max_recv_data_segment_length = block_size;
+	local_iscsi_queue_pdu = my_iscsi_queue_pdu;
+	change_cmdsn = 1;
+	/* we dont want autoreconnect since some targets will drop the
+	 * on this condition.
+	 */
+	iscsi_set_noautoreconnect(iscsic, 1);
+	iscsi_set_timeout(iscsic, 3);
+
+	ret = testunitready(iscsic, tgt_lun);
+	CU_ASSERT_EQUAL(ret, -1);
+}